Leveraging the Power of AI Coding Agents at Apptimia
- 3 days ago
- 8 min read
Updated: 2 days ago
The way software engineers write code is changing. Over the past year, AI coding agents have evolved from experimental autocomplete tools into autonomous collaborators that can explore codebases, write and run tests, deploy infrastructure, and even create pull requests — all with minimal human guidance.
An AI coding agent is, at its core, a Large Language Model (LLM) combined with the ability to execute commands in your development environment and interact with external services via a plugin system like MCP (Model Context Protocol) — think Playwright for browser automation, Figma for design, or Atlassian for project management. These agents come in two main flavors: IDE-based, such as Agent mode in Cursor or GitHub Copilot, and terminal-based, like Claude Code or Codex CLI.
The adoption numbers speak for themselves. According to a recent survey by The Pragmatic Engineer of over 900 software professionals, 95% now use AI tools at least weekly, and 75% use AI for at least half of their software engineering work. AI agent usage is rising fast, with 55% of respondents reporting regular use of AI agents, and staff+ engineers leading adoption at 63.5%.
At the same time, the rise of coding agents has sparked valid concerns. As companies push engineers to use AI more aggressively, reports of quality degradation, increased technical debt, and even production outages linked to AI-generated code are surfacing. Research suggests that while agents can boost short-term velocity, repositories with heavy agent usage show increases in cognitive complexity and static analysis warnings. The question is no longer whether to use AI agents, but how to use them responsibly so that they accelerate development without compromising quality.
At Apptimia, we have been integrating AI coding agents into our daily workflows across multiple customer projects over the past year. In this article, we share five real use cases that illustrate how we leverage these tools — along with the practices we've adopted to keep quality high.
Use Case 1: Adding Test Automation and Refactoring in Node.js Backend
One of the most straightforward and rewarding use cases for coding agents is adding missing test coverage to an existing codebase. Before writing a single test, the agent explores the existing codebase to understand its architecture, technology stack, and code design patterns. It then generates tests, runs them, analyzes failures, and iteratively fixes issues until the test suite passes. This explore-write-run-fix loop is something agents handle remarkably well.
Refactoring is a natural companion to this workflow. Once a solid test suite is in place, the agent can use existing tests as a safety net to verify that refactoring doesn't break anything. Straightforward refactoring — renaming variables, extracting functions, removing unused code — are typically handled in a single pass.
One thing worth noting: agents are surprisingly good at adhering to established coding standards and conventions. The more consistent the codebase is with its own conventions, the more likely the agent will produce code that follows them. Older models sometimes struggled with this, which is why providing explicit instructions in configuration files like CLAUDE.md or AGENTS.md was critical. With newer models, this has become less of an issue, though clear instructions still help steer the agent in the right direction — especially for project-specific patterns like test structure and naming conventions.
Use Case 2: Adding Features and Optimizing Tests in Angular/Babylon.js Frontend
For a customer project built with Angular and Babylon.js (a 3D rendering engine), we used coding agents to add new features and optimize the test suite.
A key practice here was using the agent's plan mode before implementation. In plan mode, the agent analyzes the task, proposes a step-by-step approach, and waits for the developer's approval before writing any code. This serves two purposes: it allows the developer to review and correct the plan early (saving time and tokens), and it increases the chance of building the feature correctly on the first pass.
Once implementation is complete, we iterate with the agent if the feature doesn't look or behave exactly as expected. This conversational refinement loop is where agents truly shine — you can describe what's off, and the agent adjusts.
It's worth mentioning that agents work best on React projects due to React's popularity providing richer training data for the underlying models. However, we didn't observe a significant drop in efficiency when working with an existing Angular project.
Some changes were harder to introduce in this codebase compared to the Node.js project. The Angular/Babylon.js project had weaker code design and less consistency, which made it more challenging for the agent to produce code that was correct and adhered to the project's conventions.
Optimizing tests was particularly challenging. Many tests initialized large components with a full Babylon.js 3D scene, causing massive resource consumption. Older models (Claude Opus 4) struggled with mocking Babylon.js dependencies in large Angular components and at some point started hallucinating endlessly. Newer models (Claude Opus 4.5) were much smarter about this — they could assess that optimizing tests for a large component required refactoring the component itself first, rather than just trying to mock everything.
Use Case 3: Deploying an Angular/Django Web App on AWS
This use case was particularly interesting because it involved deploying an existing platform to a completely new AWS account — and the original team that built the infrastructure was no longer with the company.
The tech stack was substantial: a Django backend and Angular frontend running on AWS ECS, with AWS RDS for the database, S3 for storage, SQS for messaging, Route 53 for DNS, and AWS Batch for heavy processing jobs. The entire deployment was managed by Terraform — or at least, it was supposed to be.
The reality was messier. The Terraform templates were outdated, relying on an old AWS Terraform provider with deprecated API calls. Worse, the templates were incomplete — some AWS resources had been added ad-hoc directly in the AWS console, bypassing Infrastructure as Code entirely. Documentation was limited, and there was nobody left to ask for clarification. This is a situation many engineering teams will recognize: inheriting infrastructure with gaps in both code and institutional knowledge.
The coding agent turned out to be remarkably effective in this scenario. It started by exploring the codebase and Terraform templates to build an understanding of the application architecture and its infrastructure dependencies. This initial exploration phase is something agents do well — they can scan hundreds of files, cross-reference configurations, and piece together how services connect without getting fatigued or losing context.
Then, the agent began deploying the application on the fresh AWS account. Whenever it encountered an issue — an incompatible Terraform provider API, a missing S3 bucket that had been created manually in the old account, or missing IAM permissions — it fixed the issues on its own when possible. When manual intervention was required, such as creating SSL certificates or configuring DNS records in Route 53, the agent provided clear step-by-step instructions for the engineer to follow.
This iterative deploy-fail-fix loop is where the agent's persistence really paid off. A human engineer would likely need to context-switch, look up documentation, and manually debug each failure. The agent handled this systematically, working through one issue after another.
At the end of the process, the agent — when asked — produced a comprehensive deployment guide in Markdown for future maintainers. This is a small but valuable detail: the very knowledge gap that made the deployment difficult in the first place was filled as a byproduct of the agent's work.
Use Case 4: Creating Prototypes of New Features in React/MapLibre Frontend
Rapid prototyping is where coding agents deliver perhaps the most impressive return on investment. Creating a fully functional prototype on an existing codebase is fast and cheap. Multiple versions can be generated, evaluated, and discarded without significant emotional or financial loss. Only the best prototype is selected and refined into production-grade code.
We experimented with several interesting techniques in this workflow:
Intentionally under-specifying prompts to let the agent come up with its own design. Rather than dictating every detail, we provided the general goal and let the agent propose a solution. This often led to creative approaches we hadn't considered.
Using multimodal capabilities to provide visual design guidance. Instead of describing the desired UI in text, we could share reference screenshots or mockups directly with the agent.
Using MCP Playwright and Claude for Chrome to verify changes and close the feedback loop. The agent could launch a browser, interact with the prototype, take screenshots, and assess whether the result matched expectations — all without the developer manually checking each iteration.
For very simple prototypes, we sometimes used Claude.ai directly to generate the prototype as a shareable artifact, which could then be sent to other team members for review before committing to any development effort.
Use Case 5: Aiding Tech Lead Work in React/Django Web App
Beyond writing and testing code, AI coding agents can significantly enhance the work of a tech lead. Here are several workflows we've adopted:
Automated Code Review. We set up a Claude-powered bot in GitHub Actions that reviews every pull request. It checks for common issues, adherence to coding standards, and potential bugs — providing an additional layer of review before a human reviewer looks at the code.
Feature Brainstorming and Specification. Using a custom Claude Skill, we generate comprehensive feature specifications from a high-level idea. These specifications are detailed enough to be handed directly to a developer, reducing back-and-forth and ensuring alignment on requirements.
Changelog Generation. Creating changelogs has traditionally been a semi-automatic chore. Using Claude Code with the Atlassian MCP server, the agent connects to JIRA, looks up all recently completed tickets, classifies each one (bug fix, feature, which part of the system it belongs to), and outputs a changelog in the exact format we need.
Code Audits and JIRA Ticket Creation. This is where the workflow gets particularly powerful. The agent audits the codebase looking for outdated dependencies, missing test coverage, code that requires refactoring, and general improvements. For each finding, it creates a JIRA ticket via the Atlassian MCP server with a suitable title, description, links between related issues, and sprint assignment. This workflow saves a significant amount of time that would otherwise be spent on manual codebase analysis and administrative ticket creation.
Summary - AI agents in coding
AI coding agents are no longer experimental curiosities — they are practical tools that, when used with the right practices, can meaningfully accelerate software development. Across the five use cases described above, we've seen agents excel at repetitive tasks like test generation and refactoring, reduce time-to-feedback with rapid prototyping, and take over administrative overhead that used to consume hours of a tech lead's week.
That said, agents are not a silver bullet. They work best when the codebase is well-organized, when the developer provides clear guidance, and when there's a human in the loop reviewing the output. The quality concerns being raised across the industry are legitimate, and they point to a need for discipline rather than blind reliance.
Looking ahead, we see two trends shaping the future of this space. First, the emergence of Agentic Software Engineering as a discipline — a set of practices, patterns, and guardrails specifically designed for building high-quality software with coding agents. This is the industry's answer to the valid skepticism around "AI slop." Second, Agent Orchestration — managing multiple agents working in parallel to further increase productivity. As tools and models continue to improve, the teams that invest in learning how to work effectively with agents will have a significant competitive advantage.
This is how we work with AI coding agents at Apptimia. If you're building complex software systems and want to leverage the latest AI tooling while maintaining production-grade quality, get in touch with us!
Bartosz Ch.
Lead Software Engineer at Apptimia
