A snapshot of my Claude Code usage patterns

I've felt my Claude Code usage change quite a bit since Opus 4.5, so I'm writing this down to archive it.

There is still a big gap between vibe coding and agentic coding: in actual coding patterns, in the quality of the output, and in the size of project each approach can handle. Vibe coding simply doesn't work for large projects, sprawling context, or complex module implementations. To keep project work moving, you have to wrap the coding agent in a thick harness and do agentic coding.

As models upgrade and the harness built into Claude Code improves, the gap will close bit by bit; but as of January 2026, this is where things stand.

Research, Plan, Implementation

I've been happily applying the workflow that these two videos both arrive at.

Everything starts from the effort to somehow conserve the agent's small, precious context window. Anyone who uses LLMs long enough learns one thing from experience: the quality of the context window an LLM gives you is not uniform. With Claude, once you're using roughly 40% of the 200k window, around 75k, you enter the so-called "dumb zone": the LLM gets dumb. So you want to finish as much work as possible inside the smart zone.

Dex Horthy's research-plan-implementation workflow shines here. Gather all the research needed to plan the work into documents, turn the research into a plan document, and then tear the plan apart with Claude until it's right. Once the plan document is solid, move on to implementation.

The strategy is to lean on external memory as much as possible and slice the work into small steps, so the context window only ever holds the information that's truly needed. I skip straight to the plan step; instead, I made a separate researcher agent, and during planning the main agent has the researcher do the research first. This still saves plenty of context window.

For real work I use a handful of commands and subagents that encode the workflow, so it's a bit more involved.

• ·/create-plan: the main agent runs an inner loop and puts researcher subagents to work. Each subagent saves its research results as a markdown file. When research is done, the main agent reads the files, goes back and forth with me a few times, and saves a plan file in markdown.
• ·/update-plan: improve the plan file until I'm fully satisfied. Researcher subagents are used here too.
• ·/research: once in a while, when Claude has missed something that needs research, I kick off the research myself.
• ·/implement-plan: once the plan review is done, it's time to build. A command for injecting a few implementation principles.
• ·/enhance-code: after implementation, run the code-reviewer and code-simplifier subagents to raise code quality.
• ·/commit-push-pr: the tedious git chores, defined as a workflow.

These days I spend far more time reviewing plan files than code. A plan file written in human language is simply nicer to read. One thing I've clearly felt: if the plan is well written, there's a very high chance the code needs no touch-ups at all. The task does have to be small enough, though; about the size an ordinary SWE could finish in 30 minutes to an hour.

Declarative over Imperative

For the most part, I don't spell out the how. Most of the plan is written declaratively, as a desired end state; only the individual phases feel at all procedural. To be fair, a lot of the how lives in command/skill/subagent definitions. If I want to steer the agent's behavior to my taste, that part is unavoidable. Still, compared to before, I write far more goals than procedures.

Meta-thinking

A prompting style I've been enjoying lately. LLMs tend to take my input at face value and process it literally. If they think meta, one level above my intent, the current situation, the context, and the implementation goal, they often reach a better perspective or solution. So these days I often prompt: "think meta about my intent and the current situation, then proceed." Of course, it often does the level of meta-thinking I want without the prompt. But forcing the mode of thought makes it follow instructions well, so overall I can expect somewhat higher-quality output.