The CHOP Shop, 2024 to 2026: How My AI Coding Setup Evolved

The Evolution of AI Coding

1. Code Completion (The Tool Fetcher): simple autocomplete suggestions, syntax error detection, basic snippet generation
2. Interactive Chat (The Apprentice): contextual code suggestions, problem-solving assistance, documentation help, bug diagnosis
3. Full Code Generation (The Master Mechanic): complete feature implementation, codebase-aware changes, convention-driven development, architectural suggestions

Cursor: From Amazing Tab Completion to the best agent

Their tab completion revolutionized how we interact with code: complete code before and after your cursor position, complete natural language descriptions into working code, jump to the next edit point (very awesome when doing rename refactoring, even across multiple variables). Pretty funny - they wanted to do tab completion, but found the VS Code extension model was too limiting for their AI ambitions. Their solution? Fork the entire VS Code codebase!

Aider: a command-line CHOP tool. Creates individual commits for each change (can be noisy), so work on a separate branch and squash commits, and let it help create unit tests. See this Aider-driven change.

Avante: a promising Vim plugin for CHOP. Excellent inline changes and merging, transparent coding prompts, integrates well with the Vim workflow.

Core Concepts

1. Natural Language Interface: express programming goals in plain English, iterative refinement through dialogue, context-aware responses
2. Codebase Understanding: AI reads and understands your entire project, follows established patterns and conventions, maintains consistency with existing code
3. Convention-Driven Development: uses CONVENTIONS.md as a knowledge base, learns from project-specific rules, maintains consistent coding standards

DRY CHOP: Your AI’s Cookbook

Think of your AI assistant as an eager junior developer who can learn and retain knowledge - but only if you teach them properly. Instead of repeating the same instructions in every prompt, establish a single source of truth through your CONVENTIONS.md file. You can see an example of this evolution here. Cursor IDE implements this concept using a .cursorrules file that points to your CONVENTIONS.md (see example). A worked example: permalink management, where AI helped establish a clear permalink change process and standardized redirect_from in front matter.

Integration Tips: create separate branches for CHOP-generated code, use commit messages that indicate CHOP assistance, review CHOP-generated changes with extra scrutiny, keep track of prompt patterns that work well.

The Art of Prompt Engineering: be specific but not too specific; reference existing components and patterns in your codebase; use AI-generated code as a foundation, not a final product. (Contradicted a month later by “prompt engineering not that important.” The later me was right.)

Cursor Tips

1. YOLO Mode for Tests: enable “run shell commands without confirmation,” perfect for running tests frequently, only enable for safe commands like tests.
2. Composer-Agent Mode: more structured, task-focused interactions, better for complex multi-step tasks, great for refactoring and architecture discussions.
3. Enable Large Context: Settings -> Features -> “Large Context”; dramatically improves AI’s ability to understand your entire codebase at once.
4. Using MCP Tools in Cursor: MCP lets AI interact with external systems via the chat interface (browser control, file operations, API interactions). Careful, it affects the real system, no undos! My tool list.
5. Claude Code MCP Servers: a GitHub server (claude mcp add github …) for issues and PRs, and Context7 so current docs land in the prompt instead of outdated APIs or hallucinated functions.

Maintain Chat History with your commits

1. Install SpecStory; it exports your chat history.
2. A zsh function, chop-git-latest, copies the latest chat to zz-chop-logs and adds it to the commit.
3. Have the AI write the commit message, but skip commenting on the logs.
4. Because the log directory sorts last, it shows up after the real change, and because the chat is linked to the commit it’s easy to track. Example: a tig configuration, with its chat.

Using latest docs: Cursor has native support for indexing docs; some projects even have an llm.txt to teach the LLM what it needs to know (FastHTML is an example).

Worktree and PR Workflow (2025-07-30)

1. Start with a worktree: git worktree add ../feature-branch feature-name. Keeps your main workspace clean, isolates AI experiments from stable code.
2. Create a draft PR early: gh pr create --draft --title "WIP: …". Establishes scope and intent, a place to track progress and chat history.
3. Use the PR description as AI context: background, related issues, the approach you want AI to take.
4. Commit frequently with descriptive messages; include CHOP session logs.
5. Convert to ready for review with gh pr ready; clean up history; include a summary of the AI assistance used.

Multi-agent orchestration stress (2025-08-13)

• Don’t feel the need to run four agents. More agents increase cognitive load and coordination overhead.
• When interventions per hour are high, adding agents makes confusion worse: parallel edits, re-explanations, and merge pain.
• Default to one strong agent with clear specs and tests; let it run longer between interventions.
• Scale cautiously to two agents only when ownership is cleanly separated and a single “conductor” coordinates.
• Prefer sequential pipelines and handoffs (spec → tests → implementation → review) over a concurrent free-for-all.
• Rule of thumb: reduce agents until stress drops and throughput rises.

How to be fast when AI is slow (2025-06-07): Once you crack the interventions per hour, your next issue is how you task swap between projects. I predict source control and multi windows are part of the solution.

YOLO Containers: Safe Full Autonomy (2025-11-16): Run AI in disposable, fully isolated Docker containers. The container has no access to your host filesystem; the AI uses its own GitHub credentials (idvorkin-ai-tools) and can only push to PRs, never to main; named volumes persist across restarts; each container gets a stable Tailscale hostname (c-5001), so ssh c-5001 drops into tmux and chrome c-5001:4000 opens the preview from any device. Setup: container configuration and management script.

claude-code-log and claude-code-transcripts: claude-code-log converts Claude Code conversation logs to publishable HTML (uv tool install claude-code-log); Simon Willison’s claude-code-transcripts does the same with pagination and gist upload.

Why Not Codex, Gemini, etc.? (written 2026-01-01 about November 2025): In November 2025, Gemini came out and I was like “Oh my god, I’ve got to try this, this is awesome.” Then the new Codex came out three days later and I was like “Oh my god, I’ve got to try this, this is awesome.” Then Opus 4.5 came out and I was like “Oh my god, I’ve got to try this, this is awesome.” Then I realized: all I’m doing is spinning between tools that keep leapfrogging each other. I decided to standardize on Claude Code and assume it’ll catch up quickly if it ever falls behind. The one gap: Claude Code can’t generate images. I use ChatGPT for that, currently manually.

The Most Expensive I Can Get (2026-01-01): Currently I’m using Claude Opus 4.5 on the $200/month plan. On one hand you might think I’m crazy spending $2,400 a year. On the other hand, imagine having brilliant collaborators who force multiply everything you do.

The Future: Multi-Agent Dashboard (2026-01-01): I was surprised when Steve Yegge mentioned this is the future - orchestrating multiple specialized agents. Surprised because I’d been accidentally building toward this. The Agent Dashboard I mentioned earlier? By the way, I didn’t build that at all. I just gave the requirements and Claude built it itself.

The Upgrade: Herdr, before Herdr (2026-01 to 2026-08): “the multiplexer” meant tmux plus duct tape - a hand-written Rust picker, windows that auto-rename to the running agent, Stream Deck keys for pane hopping.

MCP Servers and Skills (2026-01-04): At the end of the day, I don’t use much of this. Often I’ll install something, try it out, and it just gets left running in the background. GitHub MCP for issue/PR management, maybe some doc fetching. That’s about it. This stuff changes so fast, and with models getting smarter, we’ll just get to it later. Two or three max.

What I’m Still Figuring Out (2026-01-01): How to handle merges: when multiple agents touch related code, merging gets messy fast. The optimal number of agents deserves its own callout: the number you can run in parallel seems to be the limiting factor for throughput, but man, it’s easy to get confused. Sending the wrong commands to the wrong agents. Forgetting what each one is doing. Brutal merge conflicts when they touch the same files. Rethinking conventional coding wisdom: DRY vs. self-contained (should conventions be shared libraries, or should every repo implement its own? When execution is cheap, maybe copy-paste isn’t so bad). Planning vs. iterating (when you can execute so quickly, is planning even worth it?). Tests first vs. tests after (if AI can generate tests instantly, does TDD still matter?).

Where I Am Today (2026-01-23): Somewhere between stages 6 and 7. Still learning how to avoid merge hell and when to use specialized vs. generalist agents. Stage 8 is the dream.

A fascinating essay. Read path vs write path: data systems went through this, where you used to materialize writes to a DB and read from it; programs are like that too, instructions in, a program saved, a program run. But what if, in a world where models keep getting better, you store the instructions and write the code on the fly? Short term: compilers and linters designed to give LLMs more context, more small single-file programs, better decoupling because LLMs can’t keep everything in their head. On new programming languages: the existing corpus doesn’t matter, because models generate their own synthetic data, and the new languages will be of two forms, high-level ones like English to instruct the AI and AI languages optimized for AIs to read and write. New forms of technical debt: code optimized for current models that becomes a problem as models advance.

The 70% AI coding problem: AI tools dramatically increase coding speed but don’t necessarily improve quality; the last 30% of functionality is disproportionately hard; experienced developers benefit more than beginners; “bootstrappers” use AI for MVPs and “iterators” for daily work; seniors constantly refactor AI output while juniors accept it with less review.

The death of the stubborn developer: LLMs handle the repetitive leaf-node tasks; higher-level planning and coordination remain for humans but are harder to learn; the junior-to-senior pipeline is disrupted because the simple tasks juniors learned on are gone. CHOP boosts productivity by at least 30%, has a steep learning curve and no established teaching, and the author is skeptical that fully autonomous agents take over soon. Measuring the effectiveness of CHOP in enterprises remains unsolved.

Two ways to use AI. Getting help: AI as the interactive replacement for Stack Overflow, documentation, and Reddit, instant and personalized. Writing code: efficient, but should we let it take over the tasks we enjoy? The DHH clip that framed it for me is on the current page.

xipu.li on the future of coding (via a summary). Coders divide into Experimenters, who embrace AI and push abstraction up, and Guardians, who value deep understanding and robustness; Experimenters become the majority. As implementation commoditizes, the questions become “should we build this” and “how do we get people to use it,” and the non-automatable skills are understanding users, product taste, and distribution. The design doc becomes the primary artifact: edit prose to drive code changes rather than editing code directly, with parallel agents each owning a feature. (My note at the time: this is very painful. A year later, the pain is what the herd tooling fixed.)