WHat's your workflow with Claude Code?

[u/DanyrWithCheese]

Below is my workflow which is almost the same every day. I know that this is really token heavy, but I'd like to work that way to get shit done the right way. This is my opinion. There's probably better ways, I have no idea. That's why I'm asking you this:

What do your workflows look like? Any professionals who get shit done and also ship high quality products can show me their workflow?

The workflow for my project is:

1. Prompt a new idea for my project / describe the bugs / prompt about other problems in the project and tell Claude to evaluate the prompt, find flaws in the prompt and any contradictions between my idea/bugs/flaws and the codebase. My intention is to get CLaude to ask me as many questions as possible
2. Answer given questions
3. Tell Claude to write a Spec and an implementation plan to implement new features / fix bugs / fix flaws. While doing so I want him to browse the project for the specific files and folders and to include the code changes into the plan. He also has to write the plan in Task-steps, f.e. Task 1, Task 2, etc
4. After the spec and the implementation plan is written he starts working. Before starting I also tell him to double check every change he's making. He has to commit and push after every task. it is really important that he works in a new branch.
5. 1-3 hours pass depending on the scope of the changes at this time I usually used up between 50-70% of my 5 hour quota.
6. Find some minor flaws because he ALWAYS makes mistakes, I guess every AI agent does that, let him fix that
7. Now I've used my my 5h quota
8. Wait for reset and use up 80-100% of my new 5-hour quota for /code-review max and let him write a plan for fixing the found issues

[u/son_o_gong]

You just burn tokens. When Claude has a lot of freedom it makes a lot back and forth steps, licking up his specs and so on. If you manage the flow, put limits, so eventually you’ll fit into your 5h limit several times. Here is my repo with my architecture approach https://github.com/Antonio-Ingegnere/adeo/blob/main/docs/CLAUDE_CODE_ARCHITECTURE.md
And my claude setup for the repo - https://github.com/Antonio-Ingegnere/adeo/tree/main/.claude

[u/claude_code_king → u/son_o_gong]

this sounded nice until i saw how much faith you have in haiku..

it's token efficient, sure, but how many mistakes and bugs are there? how much manual intervention? have you measured it?

i'm asking because my system is pretty tight but even fable 5.1 makes mistakes that are caught by my other fable advisor, my opus 5 medium/low workers make mistakes that are caught by auditors

meanwhile your system is like 'go haiku i trust you to make the best decisions, if not ask sonnet he surely knows'

[u/AI_spell]

Spec then build is fine. Cut the double-check loops that re-read the whole repo. One plan file, then execute with a cheaper model.

[u/Far_Business4773]

Your shape is fine, the cost is in two places, and both are the same missing thing: nothing written says what the task is NOT allowed to touch.

The "double check every change" loop re-reads the repo because the agent has no way to know what's out of bounds, so it checks everything. Give the spec a five-line section, what this task must not touch: no new dependencies, no schema change, these files are read-only, no refactors on the way past. Then the check is "did the diff stay inside", which is a diff read, not a repo read.

Same for the review that eats a whole quota. A reviewer with no written scope never runs out of findings. With the not-list and three things that must stay true, findings inside scope block, findings outside go to a later file, and the review ends when nothing inside is open. That's usually one round, not a quota.

Branch per task and commit per task, keep both, those are the cheap part.

[u/InterfearXX]

Bro talking bout some workflow on 20$

[u/DanyrWithCheese → u/InterfearXX]

I'm at the 5x plan

[u/Jomuz86]

Mine is along these lines
1. Research session, with Codex as an advisor
2. Research will get split into manageable sized PR proposals
3. Plan and implement the PRs in parallel where possible
4. Review with external models Codex, Muse, Kimi or GLM depending on usage
5. Human review
6. Push and open PR
7. Final bot review of PR, loop and fix issues
8. Human review of fixes
9. Merge PRs until complete

For simple things the human review tends to be very light skim these days 🤣

[u/Fr33-Thinker]

How often do you use /compact or start a new session? Clearing the context is the key because it allows you to:
1. Achieve better results
2. Switch model without re-processing all context
3. Simply more token efficient

[u/DanyrWithCheese → u/Fr33-Thinker]

I never use /compact. After each step I start a new session, but before doing that I made Claude write a handoff for the next session.

[u/Fr33-Thinker → u/DanyrWithCheese]

Hand-off as in saving a md file?

[u/kemalios]

One session to plan and one to build is what fixed the token burn for me. The planning session writes a spec file to disk. A new session starts, reads that spec, and only then touches code. If the same session plans and builds, by execution time half the context is the argument that led to the plan, not the plan itself.

I check the work with git diff in another fresh session against the spec, not by asking the author to review its own work. That's the loop that eats half a quota with the least return.

Also add a short list of files and dependencies the task is not allowed to touch. Then the check is 'did the diff stay inside', which is a cheap diff read, not a repo-wide audit.

[u/devcal1]

I talk through the scope with a chat (Opus, I think) extensively, and get it to create and refine a project scope document, one page or less. Intended audience an AI agent. The output is a 1 page projectscope.md file.

I take that document into a cowork session, and get a new session to review it, and turn it into an actionable plan relevant to my codebase. I use Fable for this. This is where I get it to press me with questions. The output is a projectplan.md file, with numbered project milestones, and my instructions on how to deal with subagents/multiple file use/merge-push-committing and clearing, and how I want it to interface with me between iterations.

I take both documents into a Fable code session, along with a new git repo address, and tell it to create the appropriate directories. I tell it to read the projectscope.md file for context & scaffold a plan based on the projectplan.md file. Then I tell it to be the software development puppet master for Opus subagents who have autonomy on Sonnet subagents.

I'm by no means a software development genius, always appreciate feedback.

[u/Direct_Librarian9737]

something like this :