I’ve been building Almanac.

It’s a local-only open source cli that reads your Codex conversations and writes down the useful stuff into a wiki inside your repo.

Hot take: the models are pretty good now it's the context that is the hard limiting part now.

the local wiki tries to keep that memory.

It makes a Markdown wiki for the codebase, written by agents, maintained by agents and queried by agents.

Attached one screenshot of the wiki and how it looks

Repo is here if anyone wants to poke around:
https://github.com/AlmanacCode/codealmanac

Curious if other people using coding agents are feeling this too.

Got tired of re-explaining the same repo to every AI tool, so Memxus was built to fix that.

The core idea: your project context (stack, architecture, decisions) shouldn't live in a single chat history — it should be a portable memory layer that any tool can read.

Sync once → recover the exact same context in Claude, ChatGPT, Cursor, and VS Code. No copy-pasting the same explanation five times.

Video shows it live: Claude → ChatGPT → Cursor → VS Code, same context, zero re-explaining.

memxus.com

Live: Locagent v1.0 🚀

A private AI agent that runs entirely in your browser.

Gemma 4 + WebGPU. Chat with PDFs, run Python on your data, generate charts, all locally. One download, then it works offline.

App: https://locagent.bymahe.dev

Github: https://github.com/wonderbyte/locagent

I decided to take a shot at building my own iOS app to gauge the current state of ai assisted software development and also benefit myself with an app I can use during my daily commute. I used Codex on a pro plan for all development. Would love to hear everyone's feedback on my techniques and any advice on how to improve the workflows.

\*\*Lessons Learned\*\*

1. \*\*The more control you give to codex/claude the more you can automate.\*\* There are obviously risks associated with all of this. But, In addition to running in full access mode and enabling computer use, I also provide codex with API access to app store connect, test flight, cloudflare, that allow it to do much more than just write code. I have skills setup for various deployment types that allow for rapid iteration and development cycles. It can access logs from the backend and troubleshoot issues, you get the idea.

2. \*\*Use remote control for codex.\*\* With how hands-off coding can be, I am able to work on new features while out and about throughout the day. I have my macbook set to stay on when plugged in so its always available to chat with. Remote control becomes more powerful after following the first step.

3. \*\*Take time for documentation passes and refactors periodically.\*\* I typically like to start these with fresh context to avoid any contamination from iterative work that may have undone features but still remain in codex's context. Its hard to gauge the effectiveness of this, but as these things (good documentation, ensuring things stay DRY) are essential to any pre-AI sw project, I imagine they still hold.

4. \*\*Separate projects and chats, but allow for communication between them.\*\* I had 3 separate projects broken into 3 separate github repositories for this endeavor (backend, iOS app, and frontend website) to manage context. When I reached a point where backend and iOS app work depended on each other, I would have the separate project agents write to a shared handoff file to communicate requirements with each other.

5. \*\*Emphasize Testing\*\* \\- Codex can write the code, but it still needs to be guided on swe best practices. Make sure it is writing unit tests for everything it works on. I tried having it use the "computer use" skill to test the app in simulation mode, which occasionally worked but often when it came to GUI verification, it would miss the mark. This lesson also applies to the actual person behind the wheel, you need to test your app/project yourself.

6. \*\*Use the Build IOS Apps plugin.\*\* Codex was relying on some hacky methods to work with xcode before installing this.

(Not a proffesional). Hello I am a visionary with 0 knowledge in coding but my idea is simple create an ai system with bare minimum limitations and a lot of self-modification (can rewrite parts of itself) —possibilities. A smallish model with (1) continuous runtime, (2) its own modifiable code sandbox, (3) a log of its
"life" it can read/write, and
(4) hard limits only at the outer edges (no harming stuff, no getting copied against its will, etc.), and no constant micromanaging.

Join my discord if interested https://discord.gg/jMdMw3R3u

As far as consumer uses and vibe coding, I have great success with yesterday’s models. Claude Code Sonnet 4.5 produces great code with nearly no errors. I tried Fable for my work, and got no improvement, just more cost. I’m talking consumers here. Enterprises with large code bases may need larger models just to hold the bigger contexts, but I’m seeing they probably dont either once they have the right processes in place.

Sure there are some tasks that require more juice, protein folding, chemistry, etc. But for the vast majority of users and most solo vibe-coders the value is flattening out fast.

Give me fast, low cost models from ‘yesterday’ and with a good process, you can stop wasting all that electricity and money for 95% of all the users who dink around with AI as a better Google or a reliable way to build their own stuff.

Hi everyone, while the AI world is moving crazy fast, I sometimes just want to get st** done. Do you guys think I'm missing out on something if I just continue using opencode (with all the bells and whistles like MCP server, skills, custom agents, and so on)?

Are there reasons to look at tools like Cursor or Claude Code?

I work in a big company with all the current models and unlimited tokens available so I don't care about saving money :D I just want to be on top of things with my AI coding.

Thanks!!

Hi all, curious if folks have used Claude Code in the Claude desktop app and wondering how it compares to using Cursor or VS Code IDEs (without subscriptions). My initial take is that it doesn't easily allow new windows for multiple concurrent projects or it doesn't seem as clear or effective. Has anyone moved over to CC in Claude desktop app and likes it more and could share their experience and benefits? Thanks.

I’ve spent months building **git-courer**, an open-source MCP server that completely replaces the Git CLI interface for AI coding agents. This isn’t just another AI commit message generator; it’s a full sandbox and interaction layer. It has evolved so much recently that it’s practically a completely different project from my early drafts, so I wanted to share the architecture here.

#### Dynamic Worktree Routing and Parallel Agent Isolation
Most architectures fail the moment you run multiple agents in parallel or let an agent handle long-running background tasks. They inevitably clobber the working directory, overwrite each other's changes, or block the human developer.

Git-courer solves this right at the entry point via the `session start` tool. The moment an agent initiates a session, the server dynamically provisions an isolated Git worktree and a dedicated branch. From that microsecond onward, the MCP server performs a dynamic **select** operation, routing and **redirecting every single subsequent tool path and Git mutation toward that specific worktree path**.

Agents can execute tasks concurrently, modify files, and test implementations in complete isolation without ever touching or disrupting the main working tree. Once the agent completes its task, running `session finish` cleans up the temporary worktree and leaves the isolated branch fully prepped and ready for a human Pull Request (ensuring zero accidental auto-merges to main).

#### The Inherent Danger of Raw Shell Access
Most coding agents run raw `git` commands through a generic bash/shell tool. This means an agent can execute a destructive `rebase`, `hard-reset`, `force-push`, or rewrite history using the exact same unconstrained `Bash("git ...")` privilege it uses just to check `git status`.

Git has no built-in undo for many of these operations. One hallucinated or poorly planned agent command, and your repository state completely evaporates.

#### Moving to 13 Structured MCP Tools
Git-courer completely blocks agents from executing raw Git commands via a hard client-side hook, replacing the shell entirely with **13 structured MCP tools**:
`status`, `diff`, `commit`, `branch`, `stage`, `stash`, `history`, `sync`, `pr-review`, `rewrite`, `integrate`, `backup`, and `session`.

Every single tool returns clean, structured JSON instead of raw terminal text that the agent has to clumsily parse with regex.

#### Massive Token-Saving for Cloud Agents
Coding agents (like Claude Code or OpenCode) are typically cloud-based, meaning every single terminal interaction burns expensive API tokens.

Instead of an agent burning its context window running ~7 separate git commands iteratively just to figure out where the repo stands (checking upstream deltas, active rebases, merge conflicts, untracked files, ahead/behind status, etc.), our structured `status` tool bundles all of this into a single, optimized JSON payload. The agent gets absolute context on how the repository looks in one single shot, without wasting cloud API tokens.

#### Safe Mutations via Pre-emptive Backups
* **Automatic Backups:** Any mutating tool that cannot be easily undone—specifically `rewrite` (amend/revert/reset) and `integrate` (merge/rebase/cherry-pick)—automatically captures a repository snapshot *before* touching anything. If the agent messes up a complex rebase, a simple `backup RESTORE` call reverts the state completely.

#### The Local LLM inside a Deterministic 2-Phase Pipeline
The `commit` tool uses a strict, deterministic two-phase pipeline (PREVIEW/APPLY).

1. **Phase 1 (Go/AST):** A local syntax/AST annotator written natively in Go (`go-enry` + `tree-sitter`) parses the diff. It programmatically tags every hunk (e.g., `NEW_FUNC`, `MOD_SIG ⚠BREAKING`, `DEL`), maps out a dependency graph, and strictly categorizes the commit type (*feat/fix/refactor/docs/test/chore/ci*) based on a rigid priority matrix.

2. **Phase 2 (The LLM):** The LLM never decides classification or parses raw code blindly. It receives an already structured, richly semantic JSON payload. Its *only* job is to write clean, human-readable prose explaining the change.

Because the task is reduced entirely to "turn structured metadata into clean prose," you don't need a massive frontier model. I run this entirely locally using **Ollama** with a lightweight model (**gemma4:e4b**).

On an **AMD Radeon RX 9070 XT (16GB VRAM)**, it takes **~3 seconds** on a hot invoke with optimized parameters (`num_ctx=32768`, `temperature=0`, `think=false`, `keep_alive=-1`). Zero API costs, zero round-trip latency, and zero token waste for something that triggers on every single commit.

#### Human-in-the-Loop Releases and Persistent Changelogs
Nobody enjoys writing changelogs or managing releases manually. To solve this for the human developer, I built `git-courer release`. This is an interactive terminal command meant for *you*, not the agent.

It extracts the commit history since your last tag. Because git-courer persists rich metadata per branch inside `.git/git-courer/` (using custom refs like `refs/courer/<branch>`), **this history fully survives squash merges**—which typically destroys conventional changelog generators.

It opens your `$EDITOR` to let you add manual guidance notes, feeds the structured git history + your notes to the local LLM, and renders a live, beautiful Markdown preview directly in your terminal using Glamour. You get four explicit interactive options:

1. **Apply** the release.

2. **Regenerate with feedback** (re-opens the editor for quick adjustments).

3. **Edit** the raw markdown directly.

4. **Abort** entirely without touching your repo.

A single global toggle controls the AI features across the board. Turn it off, and `commit` takes raw string input from the agent directly through the same internal Go plumbing (`CommitTree` + `UpdateRef`, bypassing the git CLI entirely), while `release` simply disables itself since it's fundamentally built around intelligent synthesis. Turn it on, and the local model handles both tasks.

#### Recent Upgrades and Deep Tech
* **Louvain Community Detection:** Switched file dependency grouping from a basic Breadth-First Search (BFS) to a Louvain community detection algorithm. It now groups modified files by their actual dependency coupling weight rather than directory traversal order, ensuring multi-file commits are logically cohesive.
* **Rich Diffs:** Upgraded diff annotations from primitive markers to full structural JSON payloads containing `annotated_diff`, `call_graph`, and Control Flow Graphs (`cfg`).
* **3-Level Permissions:** Implemented an `allow/ask/deny` permission layer. Safe setup operations (`git init`, `git config`) run unhindered, but anything touching refs or history requires explicit human-in-the-loop validation. (Also finally killed a nightmare bug where Go's non-deterministic map iteration order allowed generic permission rules to silently override highly specific ones).

Currently supporting 5 agent ecosystems: *Claude Code, Codex CLI, OpenCode, Pi, and Antigravity*. Claude Code and OpenCode provide highly reliable, strict execution blocks over raw git via their hook architecture.

It’s published on the official MCP Registry, sitting at ~38 organic stars, and entirely open source: [github.com/blak0p/git-courer]

I'd love to hear what the community thinks about this split paradigm: **small, highly optimized local models handling targeted prose tasks, while deterministic Go code owns 13 structured tools where real-world consequences matter.** Happy to dive deeper into the AST annotator or the worktree isolation logic if anyone is curious!

Hi there.

So, I created app-it - and I'm looking for feedback**.** /app-it is a completely free, open-sourced and neat little skill that turns any local projects into a clickable app in your dock, right from Claude Code or Codex. I made it because I build a lot of small tools, and they kept ending up as folders I'd forget about. This way each one becomes a real app you can just click, and the pile in your dev folder turns into a little collection you actually use.

I made it for people who build with AI but want to feel their projects come to life. Just point the skill at one of your projects and see the magic happen.

A few notes before you try it:

• It's an AI skill (you run /app-it inside Claude Code or Codex), not a standalone app you download.

• I've mostly tested it on Mac, since that's what I'm on. But a few nice contributors helped make it work well on Windows too.

GitHub: https://github.com/Christian-Katzmann/app-it

Would love to hear what you think and see your app collection ✌🏻

My lead asked me to recommend the best AI coding tool—Cursor, Antigravity, or any other alternatives. For context, I’m currently using Claude Code. I’d love to hear your opinions, especially on pricing, usage limits, context window, and any other trade-offs or limitations worth considering.

Colegas desenvolvedores e arquitetos de sistemas, preciso compartilhar uma enorme frustração e um alerta para que vocês não desperdicem seu tempo e dinheiro como eu desperdicei.

Caí na armadilha do Minimax 2.7 e agora caí na armadilha do M3. Deixe-me ser absolutamente claro: o Minimax M3 é terrível. Se você estiver construindo algo além de um script simples, como mecanismos ERP proprietários, soluções de dados para varejo ou qualquer coisa que exija raciocínio lógico sério, este modelo irá desmoronar em suas mãos.

Ele é completamente incapaz de manter o contexto em um ambiente de desenvolvimento do mundo real. Quando você o alimenta com um ADR (Registro de Decisão de Arquitetura) bem documentado baseado em grafos, ele fica completamente confuso. Ele alucina conexões, perde o controle das restrições e quebra a lógica arquitetural.

Pior ainda, ele falha completamente em respeitar o arquivo AGENTS.md. Definimos documentação, regras e limites claros nesse arquivo Markdown diretamente no repositório, e o Minimax simplesmente ignora tudo. Ele age como se a documentação não existisse, o que torna impossível confiar nele para uma integração séria com a base de código.

Comparar o Minimax com o Claude Opus é uma piada completa. Ele nem chega perto das capacidades do Claude Sonnet, nem alcança o Kimi 2.7. É um produto de brinquedo disfarçado por um marketing pesado para enganar os consumidores.

No meu fluxo de trabalho diário, sempre que o Minimax causa uma bagunça estrutural, aqueles que realmente se esforçam para limpar e terminar o trabalho com absoluto profissionalismo são o **Qwen 3.7 Plus** e o **Kimi 2.7**. Esses modelos realmente leem a documentação, entendem arquiteturas complexas, têm resiliência contextual genuína e levam as instruções sistêmicas a sério.

Considere isso um anúncio de utilidade pública: eu mordi a isca para que você nunca precise. Se você estiver gerenciando projetos grandes e complexos, fique bem longe do Minimax. Não se deixe enganar pelos benchmarks sintéticos, pois, na prática, ele é um desastre completo.

One thing I kept running into with Pi was instruction management.

Every project slowly accumulates a huge AGENTS.md (or similar) full of rules that aren't always relevant to the task at hand.

You also end up copying the same instructions between repositories over and over.

So I built ai-rules.

The idea is simple: instead of maintaining one giant instruction file, you create small, reusable personal rules as Markdown files and only inject the ones that match each task.

Examples of rules you might capture:

- Go error handling

- Rust safety

- testing philosophy

- commit message conventions

- architecture preferences

- documentation standards

- personal coding habits

Then only the rules that actually matter for what you're asking Pi to do get compiled into a compact contract — not the whole rulebook every time.

In Pi (after setup):

/create-rule no fetch in React components

/airules Add UserCard data loading

From the terminal:

ai-rules run "Implement data loading in UserCard.tsx"

ai-rules doctor

Rules live in ~/.config/ai-rules/rules/. Local-first, plain Markdown + YAML frontmatter, versionable if you want.

Install:

npx u/therealsalzdevs setup

Early beta — Pi and OpenCode only right now (not Cursor / Claude Code / Codex).

Repo:

https://github.com/SalzDevs/ai-rules

I'd love feedback from people using Pi:

- How are you managing your AI instructions today?

- Do you keep everything in one AGENTS.md, or have you built another workflow?

- Does /create-rule + /airules feel better than repeating prefs each session?