DEV Community

brian austin
brian austin

Posted on

How I use Claude Code to plan and implement new features — a complete workflow

#claudecode #ai #productivity #development

How I use Claude Code to plan and implement new features — a complete workflow

Feature planning is where most developers lose time. You have a ticket, you have a codebase, but translating requirements into safe, well-structured code takes hours of reading, planning, and second-guessing.

I've been using Claude Code to compress this cycle dramatically. Here's my exact workflow.

The problem with feature implementation

Every new feature requires:

  • Understanding how the existing code is structured
  • Finding the right place to add new logic
  • Writing code that matches existing patterns
  • Handling edge cases you didn't think of initially
  • Testing that nothing broke

This is a lot of context to hold in your head simultaneously.

My workflow

Step 1: Load the feature ticket into Claude 

claude
> Read TICKET-4821.md and tell me what this feature requires at a technical level
Enter fullscreen mode Exit fullscreen mode

Claude reads the ticket and gives me a technical summary — not just restating the requirements, but identifying the specific files, functions, and data structures involved.

Step 2: Map the existing code 

> Look at src/payments/ and src/billing/ and tell me where a new payment method would need to hook in
Enter fullscreen mode Exit fullscreen mode

Claude reads the relevant directories and produces a map of where the new code needs to go. This alone saves 30+ minutes of manual exploration.

Step 3: Generate a plan before writing code 

> Before writing any code, give me a step-by-step implementation plan with the specific files you'll modify
Enter fullscreen mode Exit fullscreen mode

This is critical. I want to review the plan before Claude starts writing. It catches misunderstandings early.

Example plan output:

1. Add PaymentMethod enum value in src/types/payment.ts
2. Create src/payments/stripe-sepa.ts with the new handler
3. Update src/payments/index.ts to export the new handler
4. Add route in src/routes/billing.ts at line 142
5. Update tests in __tests__/payments.test.ts
6. Add migration in db/migrations/ for new payment_methods column
Enter fullscreen mode Exit fullscreen mode

Step 4: Implement one file at a time 

> Implement step 1 only. Show me the diff before applying.
Enter fullscreen mode Exit fullscreen mode

I don't let Claude implement everything at once. One file, review, approve, next file. This keeps changes reviewable.

Step 5: Run tests after each file 

> Run the payment tests now
Enter fullscreen mode Exit fullscreen mode

Claude runs npm test -- --grep payment and shows me the results. If something fails, we fix it before moving on.

Step 6: Edge case review 

> What edge cases haven't we handled yet? Think about network failures, invalid inputs, and currency edge cases.
Enter fullscreen mode Exit fullscreen mode

This is where Claude adds the most value. It catches things I'd normally find in code review — or worse, in production.

A real example

Last month I used this workflow to add SEPA direct debit support to a billing system. The ticket said "add SEPA support" with a link to Stripe docs.

Claude's analysis:

  • Found 3 existing payment handlers to use as templates
  • Identified a database migration needed that wasn't in the ticket
  • Caught a currency formatting issue for EUR amounts
  • Generated tests covering 12 edge cases

Total implementation time: 2.5 hours instead of my estimate of 2 days.

The rate limit reality

Workflows like this — reading multiple files, generating plans, implementing step by step — consume a lot of tokens. Long sessions with large codebases hit Claude's rate limits fast.

I use SimplyLouie as my Claude API endpoint. It's $2/month and gives me a stable endpoint I can point Claude Code at:

export ANTHROPIC_BASE_URL=https://simplylouie.com/api
export ANTHROPIC_API_KEY=your-key-here
claude
Enter fullscreen mode Exit fullscreen mode

No rate limit surprises in the middle of a feature implementation session.

The full workflow in one command sequence 

1. Read ticket → technical summary
2. Map existing code → implementation map  
3. Generate plan → review before coding
4. Implement one file → review diff
5. Run tests → fix failures
6. Edge case review → add handlers
7. Final test run → ship
Enter fullscreen mode Exit fullscreen mode

What this changes

The biggest shift is moving from "write code and hope" to "plan, review, implement, verify" — but without the overhead of doing each step manually.

Claude holds the full context of the ticket, the existing code patterns, and the implementation plan simultaneously. You just review and approve at each step.

Features that used to take days now take hours. And they're better because the edge cases are caught before code review, not after.

Using Claude Code heavily? SimplyLouie is $2/month for a stable Claude API endpoint — no rate limit interruptions mid-workflow.

Top comments (0)