Coding with Agents in 2026

I wrote about vibe coding in 2024, before “vibe coding” was a thing, about using AI to build software. It worked, in a limited way, but only just. You still really needed to know how to code.

By January 2026, the workflow looks completely different. Context windows are bigger, agents are reliable, tool calling has matured, and Ralph with superpowers ties it all together.

This is how I now build and maintain a ~30,000-line codebase.

First, get a Claude Max subscription. Its limits are huge, and you can code massive apps for a set monthly fee. I think it's the best bang for buck, at least right now.

Brainstorm

Before a single line of code is written, I plan. I launch claude code, and start with the /brainstorm tool from superpowers, giving it a one-paragraph summary of what I want to build. The brainstorm tool asks detailed follow-up questions to add more depth to the plan. This process also determines which components make up the 'app' overall. This is incredibly important, as each component has a complexity cap. I'll get into that later.

When brainstorming is complete, the tool generates a design file. I save it as PRD.md.

Now, some architecting skill comes in. If I'm building an app of any useful size, it won't be fully captured in a single design file. The PRD gives a sense of the components that are required, but then I need to brainstorm each component in more detail. I relaunch claude, reactivate /brainstorm, and prompt:

I want to brainstorm building [component] from @PRD.md, along with the initial app scaffolding.

The tool then focuses all of its attention on designing that single component, rather than the app as a whole. Crucial: you will know that the component is below the max complexity size if the design file for it is no more than ~300 lines.

Plan

Once the design for the component is created, I scan it, make any adjustments, then move on to the /write-plan phase. This converts the design into a detailed implementation plan that the agent will follow. Again, you will know that the component is below the max complexity size if the implementation plan is no more than ~1,500 lines.

I now have a high-level design of the app, and a design and implementation plan for the app's scaffold, and first component.

I make note of any external APIs that might be necessary, and create a new CLAUDE.md file. In that file, I'll put URLs to API docs, or other rules I want the implementer to follow, for example, "NEVER use mock data, or fallbacks. If live data is not available, the app simply should not work."

Implement

Now, finally, the coding begins. I switch to the /execute-plan tool, point to the @component-implementation.md, and let claude rip.

Claude builds incrementally, one task at a time, strictly bounded by the plan. It performs regular commits, and documents as it goes.

When it's finished, it should feel like Christmas morning, waking up to a gift waiting in the terminal: a bootstrapped app with its first component.

After testing to make sure the component matches the vision, I go back to /brainstorm mode and work on the next component.

This process yields the highest quality of AI-generated code. The code isn't perfect, and probably wouldn't pass the vibe-check of any senior engineer. But for end-users, it's a product that otherwise wouldn't exist, and that's enough.