I only code from a terminal now. Claude writes the code and I spend my time on the architecture and the plan. It’s not vibe coding though, I’m not accepting whatever comes back, the part of the work I do has just moved up a level.

The 3 layers

Any company has these and software is the same:

  • Tactical is writing the code.
  • Operational is how it all fits together, i.e the architecture, entire chains of features and where each piece lives.
  • Strategy is the direction of the company and the feature set, so does it actually solve the problem and which feature do you build from a product point of view.

Writing code used to be the bottom of the pyramid and it took most of my day, which is what the IDE was built for.

Claude does all of the tactical layer now. It does most of the operational layer too, it drafts the architecture and the plan, but that needs human signoff or you get slop in the design. Strategy is still mostly human with a bit of Claude. I think it’s the hardest layer to automate because it needs deep domain knowledge and you’re making bets on what customers will need next.

How I build a feature now

For anything bigger than a small fix I get Claude to do a high level architecture diagram in Figma first, so the components, the data flow and what changes. Then it writes a plan in plan mode.

I review the diagram and the plan at a high level. Mostly I’m checking that it fixes the root cause and isn’t a patch, that things live in the right place and that it’s the simplest thing that solves the problem. I push back until I’m happy with it.

Then Claude builds it in its own git worktree on its own branch, which means I can kick off tons of agents in parallel.

Tests, CI and review agents check the code. Every bug fix starts with a failing test, a review agent reads every PR and pushes the fixes it can, and a second model (GPT) reviews it independently as well. After that I check the result matches the plan I signed off.

Once a PR is merged I also ask Claude to test it again on production. I find that works well as a final check.

Why I don’t read code line by line anymore

Reviewing code line by line is pretty pointless now imo. Tests, CI and the review agents check every line and they’re more consistent at it than I ever was.

When I do find a problem it’s usually not a wrong line anyway. It’s things like duplicated logic, or a fix in the wrong layer, or a patch where the root cause should have been fixed. You can see all of those in the diagram and the plan before any code is written, so that’s where I do my reviewing.

If Claude makes the same mistake twice I add a rule for it instead of only fixing the code. Our rules live in AGENTS.md files and skills in the repo, things like how the backend is layered, where the Booking.com and Airbnb calls go, how a migration ships without downtime etc. For example Claude used to say it was done without testing end to end and I had to re-prompt it every time, which isn’t ideal, so now there’s a rule that bigger changes get tested live before it can call them done. Claude doesn’t remember anything between sessions, so if something isn’t written down it just guesses.

What I want instead

Cursor, VS Code etc are still built around the file. They’ve added agents for writing code, which is the layer that needs the least help now, and none of them really do the operational layer.

What I want is an ADE not an IDE, an agentic development environment, that only does architecture review and links it back to Claude properly. It would show me the system before and after the change as a diagram. I could comment on the plan and the comments would go straight back to the agent. Every step of the plan would link to the code that implements it, so that signing off the design is enough to trust what gets built.

Right now I stitch that together from Figma, plan mode and PRs. If someone builds this I’d pay for it.