Denshin / Blog / Engineering
Denshin × Anthropic Claude Code: How AI Pair-Programming Reshaped Our Delivery
How Denshin uses Anthropic Claude Code to scaffold features, run cross-cutting refactors, generate tests, and ship migrations in a single afternoon, without giving up code review discipline.
Denshin Engineering · Engineering Team · 30 April 2026 · 6 min read
Denshin × Anthropic Claude Code: How AI Pair-Programming Reshaped Our Delivery
For the last several months, Claude Code has sat alongside every engineer at Denshin, not as a novelty, but as a daily collaborator that ships real code into production. This post is a candid look at how we use it, what it has changed about our delivery cadence, and the specific patterns that make the difference between a clever demo and a tool the team actually depends on.
Why we picked Claude Code
We evaluated several AI coding assistants. Most of them either lived inside an editor as autocomplete or required heavy prompt engineering to do anything substantial. Claude Code stood apart for three reasons that mattered to a services-and-products team like ours:
- It runs in the terminal where work actually happens. File edits, builds, tests, git operations and shell commands all flow through one session. We didn't have to retrofit a new IDE or break our existing TypeScript / Serverless / Vite tooling.
- It reads the codebase before it writes. Long-context Claude models can hold a real understanding of a monorepo in working memory, so suggestions match our actual conventions instead of inventing new ones.
- It is governed. Permissions, hooks, and audit-friendly tool calls let us draw a clear boundary between what an AI agent can do automatically and what still needs a human to confirm.
What we use it for, day to day
Claude Code is not a single-purpose tool for us. The team reaches for it across the entire surface of a typical engagement.
1. Greenfield feature scaffolding
When we add a new module to the admin panel (say, the blog feature you are reading this post inside of), Claude Code generates the full vertical slice in minutes: the Zustand-aware page, the TanStack Query hooks, the form dialog with Zod validation, the API handler wrapped with our createHandler() helper, the DynamoDB single-table keys, and the seed script. We review, refine, and ship. What used to be a two-day boilerplate exercise becomes a same-morning task.
2. Cross-cutting refactors
The compounding cost of small inconsistencies in a codebase is enormous. Renaming a hook, introducing a new permission boundary, normalising error handling: these are precisely the kinds of changes that humans postpone because they touch dozens of files. Claude Code makes them tractable. We hand it a clear brief, point it at the surface area, and review the diff.
3. Investigations and root-cause analysis
A bug report comes in. Before we even open the file, we ask Claude Code to trace the flow from the API gateway through the Lambda, the DynamoDB key shape, the React Query cache, and the rendered component. It produces a structured trail of file/line references that compresses 30 minutes of greping into something closer to two. The fix that follows is then easy to scope.
4. Test generation and hardening
Coverage that used to lag features now lands in the same PR. Claude Code reads the implementation, generates Vitest cases for the realistic paths and edge cases, and runs them against the codebase until green. We still curate the suite (AI-generated tests are most valuable when a human chooses what to keep), but the floor of "what is tested" rose immediately.
5. Migrations
We migrated this very site from a markdown-based blog body to a Tiptap-powered rich text editor while keeping S3 image upload, per-placement crop ratios, and DOMPurify-sanitised HTML rendering all in lockstep. The migration was scoped, executed, type-checked and live in an afternoon.
The honest takeaway: Claude Code does not replace senior engineering judgement. It removes the friction between having the judgement and applying it across a real codebase.
The patterns that make it stick
A tool is only as useful as the workflow around it. A few practices have made Claude Code reliable in production work, not just impressive in a demo:
Treat the repo as the source of truth
We keep a CLAUDE.md at the root of the project that describes the architecture, the conventions, and the commands. It is the first thing the agent reads. When the codebase changes, we update CLAUDE.md in the same PR. This single habit removes 80% of the "the AI suggested something that doesn't fit" problem.
Lean on tools, not prompts
Anything that has a real action (running tests, formatting code, running typecheck, deploying) lives behind a tool the agent can call. Tool calls are auditable, scriptable, and constrained. Long natural-language instructions are not. The team writes shell scripts and yarn tasks first; the AI calls them.
Permission-gate the destructive things
Claude Code's permission model is strict by default and we keep it that way. File edits in the working tree are fine to take automatically; git push, deployments, and anything that touches shared infrastructure require explicit human confirmation. The result is autonomy where it is safe and a tap on the shoulder where it matters.
Pair, then review
We run Claude Code interactively, not as a one-shot batch job. The engineer drives the goal, Claude Code drives the keystrokes, and the diff is reviewed line by line before it leaves the laptop. This is the same review discipline we apply to a junior engineer's PR, and it is exactly the level of scrutiny AI-generated code deserves today.
What changed for our clients
The numbers we care about most are the ones our clients feel:
- Lead time on small features dropped roughly 60%. The kind of work that used to take a sprint now closes in a couple of days, with the same testing and review bar.
- Bug-fix turnaround compressed dramatically. Reproducing an issue, locating the cause, writing the fix and shipping a regression test now happens inside a single working session.
- Refactor debt shrinks instead of growing. The "we should clean this up someday" backlog is finally moving the right direction because the cost of cleanup fell.
- Engineers do more interesting work. Less mechanical typing, more architecture, design and customer conversations. That is the part that compounds.
What it does not change
It is worth being honest about the boundary. Claude Code does not replace product thinking, customer empathy, or the engineering judgement required to design a system that will be maintained for years. It does not absolve us of code review, security review, or operational responsibility. And it does not remove the need for senior engineers: if anything, it amplifies the leverage of seniors who know exactly what good looks like and can steer the agent toward it.
Where we are taking it next
Two directions:
- Codified playbooks. We are turning our most repeated workflows (adding a new entity to the admin panel, wiring a new public route, generating a new seed script) into reusable Claude Code skills the whole team can run with a single command.
- Background agents for hygiene. Scheduled agents that scan for dead feature flags, expired TODOs, dependency drift and stale documentation. The repo gets steadily healthier without any one engineer having to remember to do the work.
Closing
Anthropic shipped a tool that respects the way good engineering teams already work (files, terminals, git, code review), and added an unreasonably capable collaborator on top of it. At Denshin, that has translated into faster delivery, calmer release weeks, and engineers who get to spend their best hours on the part of the job that matters. If you are evaluating AI tooling for a serious production codebase, Claude Code deserves a place at the top of your list.
If you would like to see how Denshin uses these workflows on your own product, reach out: we love showing this in action on a real problem.
Tags: Claude Code, Anthropic, AI, Developer Productivity, Automation, Workflow
All posts · Work with Denshin