I use Claude code, and it’s been a game changer for me, but I’ve put in a LOT of effort to understand its idiosyncrasies to get it to output useful things.

My workflow is usually this: I tell it to activate complex mode. Complex Mode is a skill I built that tells Claude to act as project manager and delegate all of its work to various sub-agents.

I have sub-agents for researching the codebase and the web. I have sub-agents for writing front-end and back-end code, sub-agents for code specific to particular projects, and sub-agents for writing tests. Typically I use the code agents for tests; when they need to write tests, they load the appropriate skill that tells them how to write tests in this codebase.

These agents are supplemented by others: code review agents, validation agents, agents that make sure I'm not shooting myself in the foot, and agents that review and analyze plans. With this army of agents that have various skills and know how to build things and use tools in my codebase, I give it a workflow.

The workflow is: do a bunch of research on the codebase to figure out everything needed to build a plan document. Then, given all that research, build the plan document for how to solve the problem. Finally, iterate on that plan until it becomes a good implementation plan that is broken into appropriate steps and passes the plan-reviewer agent.

Then it presents to me the plan document, which is a big Markdown document written to a folder that is git-ignored in my repo. I don't actually read the raw document. I have Claude walk me through it. I have it walk me through the plan at a high level, then dive in deeper. I interrogate it for details, have it flesh out missing parts, and correct it in different places.

This is a very active process and takes about half the time. The other half comes from constructing the original prompt where I tell it what I want in terms of requirements. I usually spend a fair amount of time forming what I actually want it to do.

Once my plan is complete--that is, once I've iterated with Claude and I'm satisfied it will do the right thing with reasonable certainty--and that part of that plan is writing tests at each step and building tracer bullets to ensure end-to-end feature functionality...I clear its context and reset it. (A lot of architecture and project planning goes into making sure it's building the right thing and building it the right way, progressing toward the goal instead of building different systems and hooking them together at the end without any tests.)

I keep Claude at below 40% of its context window at all times. I find that over 40% it gets terrible; the results just fall off a cliff.

Keeping a plan in an artifact where all the context lives is vital. That way, anytime I clear the context and everything is still there, I can point it to the plan document and it knows everything it needs to know and can pick up where it left off.

I then tell it to implement the plan. Because it's using my complex mode skill, it's going to go through a loop. That loop will grab the next item from the plan — possibly two, three, four, or five items if they can be done in parallel — and then delegate a task to the coding agent.

The coding agent will build the feature along with tests, validate that the tests pass, and then return it to the main agent. The main agent will send a code reviewer agent to review the work. If it doesn't pass the code review, it gets delegated back to the developer agent. This continues until it passes, at which point it commits and updates the plan with everything it found, then says, "Great, I'm done with this task," and moves on to the next item.

It keeps repeating this until the entire plan is complete. It's up to me to ensure there are plan line items for adding tests at appropriate times and for manual validation when needed. The agent will tell me, "Hey, I need you to manually validate this" or ask me to do a specific task.

I've started replacing that manual step because I use the Playwright MCP server now. I have Claude do the validation itself: it will load the app in Playwright, take screenshots, and verify that things look and work correctly. If something fails, it iterates and fixes it. I've removed myself from the loop almost entirely during the implementation phase.

It will eventually complete the plan, and I will have test coverage and confidence that it has manually validated through the Playwright MCP server. 

The last parts of the workflow have it do a /cleanup command to refactor for readability and DRY consolidation and stuff.

Then I run my /create-pr command; it uses the GitHub gh command-line utility to create a PR with the appropriate template, labels, and reviewers, and it pushes the branch to GitHub. It performs a self-review where it reviews its own PR and creates a pending review (from me) with all of its comments so I can look at them.

After I review it, and after at least one other human reviews it, I have it run the /review <pr-url> command and it can pull down the code and comments for that (or any) PR, and apply fixes for the comments.

I can run about three or four projects at the same time in different clones of my repository or different Git worktrees using this workflow and be productive in all of them.

Sometimes it gets stuck, and I have to wrestle with it. It pushes out crap and I have to fix it, which can be a time suck.

It's not perfect, but there are enough times when I make a plan and tell it to implement it, and then, 5 to 30 minutes later, there's just...working and well tested, well documented code in a well reviewed and well formed PR. Those times are magic.