My AI-Assisted Development Workflow with Claude Code in 2026

There is a lot of hype around AI-assisted coding. Most of it focuses on the wrong thing — generating code faster. But speed without structure is just chaos delivered quicker.

What actually matters is how AI fits into a disciplined engineering workflow. I have been using Claude Code (Anthropic’s CLI agent) as my primary development partner for the past several months across multiple products — SystemDox, FaceGov, and client projects. Here is the workflow that actually works.

The Four-Phase Workflow

Phase	What Happens	AI Role
1. Identify & Analyse	Spot the problem, review existing code, understand the context	Research assistant + second pair of eyes
2. Plan & Scope	Create an epic with well-defined issues on the project board	Spec writer + scope validator
3. Implement	Write the code, guided by the plan	Pair programmer with full codebase context
4. Test & Verify	Validate the change works end-to-end	Test writer + reviewer

This is not “ask AI to build the thing.” It is a structured collaboration where I stay in the driver’s seat and Claude handles the heavy lifting under my direction.

Phase 1: Identify and Analyse the Problem

Every feature or fix starts with understanding — not coding. This is where most developers (and most AI tutorials) skip straight to the wrong step.

What I Actually Do

1. Spot the issue — a bug report, a missing feature, a performance problem, or a pattern that does not scale.
2. Review the relevant code — I read the code myself first. I need to understand the current state before I can evaluate AI suggestions.
3. Ask Claude to analyse — with the codebase loaded, I ask Claude to examine the area in question. It can grep across repos, read related files, trace dependencies, and surface things I might miss.

Why This Order Matters

If you jump straight to “Claude, fix this bug,” you are delegating understanding. That is the one thing you should never delegate. Claude is excellent at finding patterns, tracing call chains, and spotting inconsistencies — but you need to know enough to judge whether its analysis is right.

2026 best practice: Contextual AI, not blind AI. Claude Code operates directly in your repository with full file access. Use that. Point it at specific files, ask it to trace specific flows. The more precise your question, the better the answer. Vague prompts like “make this better” produce vague results.

What Good Analysis Looks Like

A typical analysis session might go like this:

Me: "The WebSocket reconnection is dropping messages after a network
     interruption. Look at the streaming recovery flow in
     backend/functions/streaming/ and the client-side handler
     in apps/app/src/services/streaming.ts"

Claude: [reads both sides, identifies the race condition,
        explains the gap between disconnect detection and
        reconnect, suggests the fix with specific line references]

Claude does not just find the bug — it explains the why, which helps me decide on the right fix rather than a quick patch.

Phase 2: Plan and Scope with Epics

This is where discipline separates professional development from hacking. Before writing any code, I create a proper plan.

Creating an Epic on the Project Board

I use GitHub Projects at the organisation level with custom fields for Epic and Phase. Every meaningful piece of work gets:

1. An epic — a coherent group of 3-8 issues that deliver one capability
2. Individual issues — each scoped to a single pull request, with clear acceptance criteria
3. Dependencies mapped — so implementation order is obvious

How Claude Helps with Planning

Claude is surprisingly good at breaking down work:

• It can read the codebase and suggest what files need to change
• It can identify dependencies between issues (e.g., “the API endpoint needs to exist before the frontend can call it”)
• It can draft acceptance criteria in Given/When/Then format (following our shared-specs convention)
• It can estimate complexity and flag risks

I ask Claude to draft the epic and issues, review them myself, adjust the scope, and then create them on the board. The AI accelerates the planning — but I own the decisions.

2026 best practice: Specs before code. For non-trivial features, write specifications using a structured format (proposal + Given/When/Then scenarios + task breakdown) before implementation. This is not bureaucracy — it is how you catch design mistakes before they become code mistakes. AI can draft these specs quickly, making the overhead minimal.

2026 best practice: Small, atomic issues. Each issue should map to one pull request. If an issue requires touching more than 3-4 areas of the codebase, it is too big. Claude can help you split it. Small PRs are easier to review, easier to revert, and easier for AI to implement correctly.

Phase 3: Implement

Now — and only now — we write code. With a clear plan and well-scoped issues, implementation becomes the straightforward part.

How I Use Claude Code for Implementation

1. One issue at a time — I pick the next issue from the epic in dependency order.
2. Set the context — I tell Claude what issue we are working on, point it at the relevant spec, and let it read the files it needs.
3. Collaborate, do not dictate — I describe what needs to happen at a high level. Claude proposes the implementation. I review, adjust, and approve.
4. Commit incrementally — small, focused commits with clear messages. Claude can draft these too.

Patterns That Work

Let Claude read before it writes. The biggest improvement in my workflow came from insisting that Claude reads the existing code and tests before proposing changes. It catches conventions, patterns, and edge cases that would otherwise get missed.

Use CLAUDE.md files. Every repository has a CLAUDE.md with project structure, conventions, and banned patterns. This is Claude’s “onboarding document” — it reads it at the start of every session. Keep it up to date and your AI pair programmer stays aligned with your architecture.

Cross-repo awareness. Claude Code can access multiple repositories simultaneously. When a change in one repo affects another (e.g., updating a shared auth contract), Claude can trace the impact across the entire system. This is genuinely powerful for monorepo and multi-repo setups.

2026 best practice: AI-readable project documentation. Your CLAUDE.md (or equivalent) is not just for the AI — it is the single source of truth for project conventions. If a human cannot understand your project from reading it, neither can the AI. Treat it as living documentation.

2026 best practice: Architecture fitness tests. Automated tests that enforce architectural rules (e.g., “no direct Sentry imports outside the wrapper,” “all APIs must use the shared authoriser”). These catch violations immediately — whether the code was written by a human or an AI. Claude respects these constraints when it knows about them.

2026 best practice: Memory and context persistence. Claude Code supports persistent memory across sessions. Use it to store user preferences, project decisions, and feedback. This means Claude does not start from zero every conversation — it remembers your architecture decisions, your coding style preferences, and what approaches worked or failed in the past.

Phase 4: Test and Verify

Testing is not optional, and “it builds” is not testing.

My Testing Checklist

1. Type checking passes — pnpm build or equivalent. This catches structural issues.
2. Unit/integration tests pass — existing tests still green, new tests cover the change.
3. Visual verification — for any UI change, I run the dev server and check it in a browser. A passing build does not mean the CSS loaded or the component renders correctly.
4. End-to-end flow — walk through the golden path manually. Then try the edge cases.
5. Cross-browser/device spot check — at minimum, test on Chrome and one mobile viewport.

How Claude Helps with Testing

• Writing tests — Claude can generate test cases from the acceptance criteria in the issue. BDD-style tests (Given/When/Then) translate almost directly into test code.
• Reviewing coverage — ask Claude to check what scenarios are not yet tested.
• Code review — before merging, I ask Claude to review the diff. It catches things I miss after staring at the same code for hours: missing error handling, inconsistent naming, potential regressions.

2026 best practice: AI-generated test cases from specs. If you wrote Given/When/Then specs in Phase 2, Claude can generate the corresponding test implementations almost automatically. This closes the loop between planning and verification.

2026 best practice: Security review as a gate. Before merging any PR that touches authentication, authorisation, API endpoints, or data handling, run a security review. Claude can perform a structured security analysis checking for OWASP top 10 vulnerabilities, injection risks, and access control issues. Make this a habit, not an afterthought.

2026 best practice: Do not trust AI output blindly. This applies to testing most of all. AI-generated code can look correct, pass linting, and even pass basic tests while containing subtle logic errors. Review the logic yourself. Run the code. Check the actual behavior. The AI is your assistant, not your replacement.

What I Have Learned (The Non-Obvious Bits)

AI Works Best with Constraints

The temptation is to give AI maximum freedom. The reality is the opposite — AI produces its best work when heavily constrained. Architecture fitness tests, CLAUDE.md conventions, typed schemas, small issue scopes — all of these constraints make AI output more reliable.

Planning Is Where AI Saves the Most Time

Most people think AI coding assistants save time during implementation. In my experience, the biggest time savings come from Phase 2 — planning. Breaking down an epic into well-scoped issues, writing acceptance criteria, identifying dependencies — this used to take hours. Now it takes minutes, with better results because Claude can cross-reference the actual codebase while planning.

The Feedback Loop Is Everything

When Claude does something well, I let it know. When it makes a mistake, I correct it and explain why. Claude Code’s memory system means these corrections persist. Over time, the AI genuinely gets better at working on your specific project. It learns your patterns, your preferences, and your architecture. Invest in this feedback loop early.

Do Not Skip the Human Judgment

AI accelerates every phase of this workflow. But it does not replace the judgment calls: Is this the right feature to build? Is this the right architecture? Is this trade-off acceptable? Those decisions remain yours. Keep it that way.

The Workflow in Practice

Here is a concrete example from last week. I needed to add a new email template system:

1. Identify — reviewed the existing email handling, asked Claude to map all the touchpoints across shared-auth and shared-notifications
2. Plan — created an epic with 5 issues: template schema, rendering engine, integration with SES, migration of existing templates, and tests
3. Implement — worked through each issue in order, with Claude implementing under my direction
4. Test — verified each template rendered correctly, tested the SES integration, ran the full email flow end-to-end

Total time from problem identification to merged PRs: roughly half what it would have taken without AI assistance. And the quality was higher because the structured planning caught two design issues before they became code.

Getting Started

If you want to adopt this workflow:

1. Set up CLAUDE.md in your repository. Document your project structure, conventions, and patterns. This is the highest-leverage thing you can do.
2. Start with Phase 1 and 2 — use AI for analysis and planning before you use it for coding. This builds trust and teaches you how to collaborate effectively.
3. Invest in architecture fitness tests — these are your safety net. They ensure AI-generated code follows your rules.
4. Build the feedback loop — correct the AI when it is wrong, confirm when it is right. The persistent memory makes this compound over time.
5. Keep yourself in the loop — review every change, understand every decision. The moment you stop understanding what the AI is doing, you have lost control of your codebase.

AI-assisted development is not about typing less code. It is about thinking more clearly, planning more rigorously, and executing more consistently — with an incredibly capable assistant handling the mechanical work while you focus on the decisions that matter.