Once you use a coding agent every day, the model itself stops being the main lever. What changes the experience is the stuff around it: how you write the instruction file, whether every MCP schema lands in context on every turn, how you split work across trees, and whether the UI the agent ships still looks like an AI demo. I keep short reading notes on that peripheral stack in my digital garden. These eight are the ones I reopen most. None of them are tools I built — they're third-party projects and posts, and the takes below are just my own.

Keep CLAUDE.md short and general

An LLM does not remember your codebase across sessions, so CLAUDE.md (or AGENTS.md) is the onboarding doc it rereads every time. The useful frame is WHAT / WHY / HOW: stack and layout, why the project exists, how to build, test and typecheck. Stuff that only matters for one task tends to get ignored — Claude Code even injects a system-reminder that context might be irrelevant — so the more specific the file gets, the more of it the model quietly drops. Prefer progressive disclosure (pointers to other markdown files, file:line instead of pasted snippets), leave style to linters, and write the root file by hand instead of trusting /init. I sketched the argument in my notes on writing a good CLAUDE.md.

Stop shipping every MCP schema every turn

Add a few MCP servers and the tool definitions alone start eating the context window. mcp2cli takes the opposite approach: at runtime it turns MCP servers, OpenAPI specs or GraphQL endpoints into a CLI, with no codegen. Claimed savings are 96–99% of the tokens you'd otherwise spend on schemas each turn. It handles OAuth (fetch, cache, refresh), passes secrets via env: / file: prefixes, can bake named connection configs, and has --json / --toon output aimed at LLMs. The mental model I like is simple — tell the agent "call the CLI when you need it" instead of stuffing every tool definition into the prompt.

When you do want MCP as the agent substrate

If you'd rather build on MCP than work around it, lastmile-ai's mcp-agent is the cleanest Python take I've found. It treats Anthropic's "Building Effective Agents" patterns (router, orchestrator-workers, evaluator-optimizer, swarm and friends) as composable pieces, manages MCP server lifecycles, and can grow a simple agent into a Temporal-backed durable workflow with pause, resume and retry — without changing the agent API. You can also expose the app itself as an MCP server for Claude Desktop or Cursor. More detail in this mcp-agent overview.

An open-source coding agent with permission tiers

For a terminal agent you can actually install many ways (npm, Homebrew, scoop, pacman, a desktop app), look at sst's OpenCode. What stuck with me is how it splits built-in agents by privilege: build is full-power, plan is read-only and asks before running bash, and @general is a subagent for multi-step search. Cutting permissions per agent rather than per tool call is a design I'd like more harnesses to copy. Here's my short OpenCode note.

Read other products' system prompts (carefully)

Curious what a well-tuned agent is being told under the hood? The community repo that collects system prompts, tool defs and model notes for Cursor, Devin, Replit, Windsurf, v0 and others is a useful comparison set — with the usual caveat that these are unofficial dumps, not vendor docs. At ~144k stars it's hard to miss. I use it when rewriting my own CLAUDE.md or tool descriptions; see the system-prompts collection write-up.

Design skills that scrub the "AI look"

Ask an agent to build a UI and you often get the same gradients and card stacks. Impeccable is a design-skills pack for coding agents (Claude Code, Cursor, Codex, OpenCode and others) with commands like typeset, layout, polish and audit, plus 61 detection rules aimed at the usual AI tells. The operational bit I liked: keep a PRODUCT.md and a DESIGN.md so later agents inherit the product constraints and visual system. Notes here: Impeccable design skills for AI harnesses.

Git worktrees as concurrent activity slots

On the human side of the workflow, matklad's write-up on git worktrees changed how I parallelize agent work. He doesn't treat worktrees as a branch substitute. He keeps five fixed ones — main (read-only snapshot for comparison), work, review, fuzz, scratch — and assigns each to an activity that can run at the same time. That maps cleanly onto "agent reviewing over here while I implement over there." Dig into how matklad uses git worktrees.

An extreme case: 2,500 PRs in a month

Finally, a different kind of signal: lauren's X thread on shipping 2,500 PRs to production in a month (originally meant for Cursor Compile in London). The claim isn't "type faster" — it's that weak type systems and lint rules only go so far, and once a codebase can formally verify itself, review stops being the bottleneck and shipping gets very fast. They're bullish on Bend for that reason. Not a playbook you copy tomorrow, but a useful upper bound on how much verification you can push onto the machine. Summary in my note on the 2,500-PR month.

Put together, the productivity of a coding agent seems to depend less on which model you pick and more on keeping instructions short, not polluting context with tool schemas, giving concurrent work its own trees, and moving verification onto something deterministic. If any of these look useful, the notes above link through to the original repos and posts.