Workflow of the Week Collection

I publish Agentic Coding Weekly every Monday. If you want new workflows like these in your inbox, subscribe below.

I've been closely tracking AI-assisted coding since the ChatGPT launch. My goal is to have an eye on the bleeding edge, but to not be caught up chasing every new thing. There's a lot of churn and FOMO in the space, but things also get "baked-in" very quickly, and it's important to remember, the point is to save time and effort. My goal is Pareto efficiency: see what is boiled-down post-hype, adopt what gives the best gains for my actual work (vs yak-shaving).

Opus 4.5 and GPT 5.2 were the biggest game changers for me and since their release, now do 99% of my code-writing. Before that, I was mostly still going through most of my code (e.g., except for one-off scripts I didn't care about), but I've now switched mainly to enforcing quality through specs and test coverage even for long-lived projects (the latest models can spelunk and parse code better than I can).

This is in a state of flux as new scaffolding comes out and I've been poking at new scaffolds and control planes, and I fully expect my setup to look quite different in 6 months, but my main setup currently is byobu with aggressive F8 pane labeling:

I mostly use Codex and Claude Code, but use some Amp and OpenCode as well. I've tried some mobile/web prompting flows (Happy, etc) but generally byobu (tmux) via Tailscale is how I manage everything. This lets me run my agents and access them remotely when I want, and is an easy adaptation of the same sort of workflow I've used for years (but with AI agents coding).

My general preference is to run the strongest models available. As of my latest testing, GPT-5.3 Codex xhigh is the strongest general coder for my workload, and I run Opus 4.6 for writing, planning and more interactive flows and also use GPT-5.2 xhigh for planning, review and deep work (leaving it alone for minutes/hours).

I have a custom ccstatusline and use ccusage and @ccusage/codex for some stats tracking as well, but besides that am pretty vanilla on my plugins/addons.

Historically I've leaned heavily into using Deep Research for research, but I've increasingly been migrating those ad-hoc queries into git repos/agentic coding tools for rapid iteration. Putting everything into agent-accessible markdown files is a huge multiplier.

As mentioned, I don't trick out my setup. There's a whole cottage industry of Claude Code plugins, custom skills, and meta-frameworks, and while I keep a repo/doc tracking and analyzing the major ones like superpowers, get-shit-done, etc., a well-written AGENTS.md seems to cover most of my needs.

My AGENTS.md (and symlinked CLAUDE.md) is where the core of my current process lives. Each project has a custom AGENTS.md that I've been evolving. Versions are shared with the rest of my (human) team as well. Despite having boiled down my best practices, my AGENTS.md is not super long - currently about 250 lines.

The most important bits in my AGENTS.md:

Most of this is self-explanatory, but the most important part is probably my spec-driven development loop, especially the independent review loop.

IMO, spec drift is where most people get in trouble with AI-assisted coding, and process is mostly about helping to keep you and your agents out of trouble on that front:

Despite basically not touching the code anymore, I feel like I still have a decent grip of what's being generated and I'm currently still very hands-on with managing my agents on coding sprints. The amount of engineering-effort from my side probably remains the same, but features (and new business lines) land much more quickly. While some people have adopted more chaotic flows, for now, I still try to keep the development as intentional as possible.

I also have an explicit "meta" rule at the end of my AGENTS.md:

In practice though, my post-sprint analysis is where I'll review with my agents to see what actually needs to be changed or updated in the AGENTS.md.

Over the past 30 days, I've clocked in a pretty large amount of token usage, although 90-95% of those are cached tokens. I subscribe to ChatGPT Pro, and even at relatively high token usage, I have not been hitting any usage limits (the $200/mo is worth it). The Claude models I use via Bedrock and Vertex.

What are these tokens used for? Over the past month, I've had multiple projects baking, including one optimizing GPU kernels, a new custom model training framework, multiple new evals, papers and blog posts and grant proposals, several training research plans, and also, most recently, two new 30K+ LOC greenfield projects.

— Leonard

I'm very much a terminal guy, so I focus on using CLI tools in a way that maintains control over the output.

I primarily use Claude Code in the terminal for actual coding, complemented by ChatGPT in the browser for research and planning. Occasionally I'll use Gemini for drafting UI parts since I've found it much better at spatial understanding.

For quick read-only exploration of a new codebase, I like using Gemini 3 Flash which has an impressive price/speed/quality balance. Used to call it through aider but switched to charmbracelet/crush in the last few months.

I keep Claude Code largely vanilla, using a few MCP servers sporadically. I'm not currently using Agent Skills. Tried it when it was first introduced but found it hard to robustly control model behavior. Instead, I prepare a Makefile with self-documented targets, which are runnable by both agents and humans. It allows me to precisely control how the model runs and tests the codebase. I also pre-approve most tools to Claude and restrict access to specific files using standard file system permissions.

I mostly draft the CLAUDE.md for projects manually, but when I let it be auto-generated I review and trim it down cause LLMs like to be too exhaustive and include irrelevant details, which hurts focus down the line.

When the model is stuck or things don't go as I like, instead of adding more instructions I often reset context and have the model work on a sub-problem first, then integrate that solution into the broader project. If that's still not working... I just do it myself!

— Paul

Christoph primarily uses ChatGPT or Codex web. He's tried Claude Code and some open models, but never vibed with any of them. He prefers to stay in control, not a fan of terminal agents touching files on his computer. He wants agents to work in their own environment and send him the results for review.

The approach is fire and forget. He doesn't always know what a solution should look like, and he's not a fan of specs. Code wins arguments. He fires off a prompt, looks at the results, and if it's not right or doesn't work, starts a fresh chat with a refined prompt. Planning happens in a regular ChatGPT chat with a non-Codex Thinking or Pro model.

He typically fires off 3-5 Codex sessions before stepping away from the computer or going to sleep, then works through each solution one by one. When done with a task, he archives all the chats and moves on.

A few things that he finds useful: turning memory off and starting a fresh chat for every question. Keeping a strict project structure so the model has rails to follow, then heavily editing and rewriting anything it generates before it touches the repo. Getting good at prompting a specific model, as the same prompt doesn't work as well with other LLMs. Building intuition for what it's good at and adjusting when a task takes more (or less) time than expected. Finally, treating the prompt input bar as a replacement for the todo list. Instead of filing a task, he drops the thought into a prompt. The change ships in an hour instead of sitting in a backlog forever.

I use an OSS coding agent orchestrator called vibe-kanban and give it the task prompt. It creates separate git worktrees and runs independent Codex agents for each task.

If the task is genuinely hard or ambiguous, I’ll kick off multiple runs with slightly different instructions, or just switch the Codex model (for example GPT-5.2 vs GPT-5.1 Codex Max). This tends to surface different tradeoffs: one version might be safer and boring, another might be over-engineered, another might match the existing architecture better. Since each implementation is isolated in worktrees, it’s easy to compare approaches without branches getting tangled.

I noticed that these models often over-engineer the implementation. So I add following instructions in the project AGENTS.md file:

Once the agents finish, I deploy each worktree and test in the browser. Anything that fails basic self-QA gets dropped early. For the ones that look promising, I open a separate Codex session and have it score and compare them. The score is subjective, but it’s useful for forcing a clear decision.

Here’s the exact comparison prompt I use:

Finally, I select the winning worktree, issue small follow-up instructions for final polish, and create the PR.

— Eunsu