Six months ago, we made Claude Code a standard part of every developer's toolkit at Pepla. Not as an experiment. Not as a side project. As a core workflow tool, sitting alongside the terminal, the IDE, and the browser. The results have been significant enough that we think it is worth sharing what we have learned -- both the wins and the places where AI assistance falls flat.
What Claude Code Actually Is
Claude Code is Anthropic's agentic coding tool that runs directly in your terminal. Unlike browser-based chat interfaces where you copy and paste code snippets back and forth, Claude Code operates in the context of your actual project. It can read your files, understand your directory structure, run commands, execute tests, and make edits across multiple files in a single operation.
Claude Code operates inside your project context -- reading files, running tests, and editing code in one agentic loop.
Think of it less like a chatbot and more like a very fast pair programmer who has read every file in your repository and has perfect recall. You describe what you want to accomplish in natural language, and it works through the problem -- reading relevant code, proposing changes, and applying them when you approve.
The key architectural difference from earlier AI coding tools is the agentic loop. Claude Code does not just generate a block of code and hope for the best. It reads, plans, acts, observes the results, and iterates. If a test fails after a change, it can read the error, diagnose the issue, and fix it -- often without you needing to intervene.
How It Fits Into Our Development Workflow
At Pepla, we do not use Claude Code for everything. We use it where it genuinely accelerates delivery without sacrificing code quality. After months of iteration, we have settled on several primary use cases.
Code Generation for Well-Defined Tasks
When the requirements are clear and the patterns are established, Claude Code is remarkably effective. Creating a new API endpoint that follows your existing conventions, building CRUD operations against a defined schema, writing data transformation functions with clear input/output specifications -- these are tasks where AI assistance shines.
A practical example: one of our teams needed to build 14 new REST endpoints for a client's reporting module. Each endpoint followed the same pattern -- controller, service layer, repository, DTOs, and validation. A developer described the pattern using the first endpoint as a reference, and Claude Code generated the remaining 13 with correct naming, consistent error handling, and proper typing. The developer reviewed each one, made minor adjustments, and what would have been two days of repetitive work was done in three hours.
Refactoring and Modernisation
This is where Claude Code has surprised us most. Refactoring is tedious, error-prone, and usually gets deprioritised because it does not deliver visible features. With AI assistance, the calculus changes.
We recently migrated a legacy Angular component library from RxJS patterns to signal-based reactivity. Claude Code understood both paradigms, could identify the transformation patterns, and applied them consistently across dozens of files. The developer's role shifted from manually rewriting code to reviewing transformations and handling the edge cases the AI flagged but could not resolve on its own.
The biggest productivity gain is not in writing new code faster. It is in making refactoring cheap enough that teams actually do it.
Test Writing
Most developers would rather write features than tests. Claude Code does not have that preference. Point it at a module with insufficient coverage, and it will generate meaningful test cases that cover happy paths, edge cases, and error scenarios. It reads your existing test patterns and matches them -- if you use Jest with a specific assertion style, it follows suit.
We have found the generated tests to be a solid starting point. They typically cover 80% of what you need, and the developer adds the remaining cases that require domain knowledge the AI lacks. Our average test coverage across projects has increased from around 62% to 84% since adopting this workflow.
PR Review Assistance
Before a developer submits a pull request, they can ask Claude Code to review the diff. It catches things that are easy to miss in self-review: inconsistent error handling, missing null checks, potential performance issues with nested loops, unused imports that slipped in during development. It is not a replacement for human code review -- it is a pre-review that raises the baseline quality of every PR before it reaches a colleague.
AI pair programming works best when developers lead with clear intent and review every output.
When Not to Use It
This is the part most articles about AI tools skip, and it matters more than the success stories.
Architecture Decisions
Claude Code can implement an architecture, but it should not be choosing one for you. Deciding between a microservices approach and a modular monolith, selecting a state management strategy, designing a data model for a complex domain -- these decisions require understanding business context, team capabilities, operational constraints, and long-term maintenance implications that an AI simply does not have.
Security-Critical Code
Authentication flows, encryption implementations, access control logic -- we always write these by hand with careful review. AI-generated security code can look correct while containing subtle vulnerabilities. The cost of getting security wrong is too high to optimise for speed.
Novel Problem Domains
When you are working in a domain with little existing reference material, or solving a genuinely novel problem, AI assistance becomes less reliable. It excels at pattern matching and applying known solutions to new contexts. It struggles when there are no patterns to match against.
When You Do Not Understand the Problem Yet
If you cannot clearly articulate what you want, Claude Code will cheerfully generate something that looks plausible but misses the point. AI assistance works best when the developer has a clear mental model of the solution and uses the tool to accelerate implementation. Reaching for AI before you understand the problem is a recipe for wasted time.
The Productivity Numbers
We have been tracking delivery metrics across our teams since adoption. The numbers are not as dramatic as some vendors claim, but they are real and consistent.
- Time on boilerplate tasks has decreased by roughly 40-50%. This is the clearest win.
- PR turnaround time has dropped by about 25%, largely because pre-review catches issues earlier.
- Test coverage increased from 62% to 84% average across projects.
- Refactoring frequency has approximately doubled. Teams are paying down technical debt because the cost of doing so has dropped significantly.
- Overall feature delivery speed has improved by roughly 20-30%, depending on the project type.
Notice what is not on this list: we have not reduced team sizes. The productivity gains go into higher quality, broader test coverage, more refactoring, and faster delivery -- not into doing the same work with fewer people.
Track metrics before and after AI adoption -- gut feelings about productivity are unreliable.
The Learning Curve
It takes about two weeks for an experienced developer to become genuinely productive with Claude Code. The first few days involve over-relying on it for things you are faster at doing yourself, and under-utilising it for tasks where it genuinely helps. The calibration takes time.
The developers who get the most value from it share a common trait: they are good at decomposing problems into clear, bounded tasks. They do not ask the AI to "build the user management system." They ask it to "create a password reset endpoint that follows the pattern in auth-controller.ts, validates email format, generates a time-limited token, and sends a reset email via the notification service." Specificity drives quality.
The developers who benefit most from AI assistance are the ones who were already good at breaking problems into small, well-defined pieces.
What This Means for Development Teams
AI-assisted development is not a future consideration anymore. It is a present-tense competitive advantage. Teams that adopt these tools thoughtfully -- understanding both their capabilities and their limitations -- deliver faster, at higher quality, with better test coverage.
The operative word is "thoughtfully." Dropping an AI tool into a team without guidance about when to use it and when not to use it creates more problems than it solves. You need clear conventions, shared understanding of appropriate use cases, and a culture where developers feel comfortable saying "I wrote this by hand because the AI was not the right tool for this task."
At Pepla, Claude Code has become as natural a part of our workflow as version control. We cannot imagine going back. But we also cannot imagine using it without the engineering judgement and domain expertise that make it effective. The tool amplifies the developer. It does not replace them.
AI-assisted development is not about replacing developers -- it is about amplifying engineering judgement.
Practical Takeaways
- Start with well-defined, repetitive tasks -- boilerplate, CRUD, test generation -- where the ROI is immediate and the risk is low.
- Establish team conventions for AI use: what tasks are appropriate, what requires human-only implementation, how AI-generated code should be reviewed.
- Invest in prompt specificity. Vague instructions produce vague results. Reference existing code patterns explicitly.
- Track metrics before and after adoption. Gut feelings about productivity are unreliable -- measure PR cycle time, test coverage, defect rates, and delivery velocity.
- Do not expect AI to replace architectural thinking, domain expertise, or engineering judgement. Expect it to handle the mechanical work so your team can focus on those higher-value activities.
