AI-Assisted Software Development in Practice

Seven development workstreams. Two engineers. 22% of engineering effort saved.

These were the results of a CodeLink software engineering project that incorporated AI into daily development. While the figures don't establish how much time AI independently saved, they provide a practical view of how AI-assisted software development operates in a production project.

For CodeLink, AI is an addition to established engineering practices, not a replacement for them. Our approach focuses on applying AI to specific development tasks while maintaining technical accountability.

Here's how we put that approach into practice, where it supported delivery, and what we learned.

Key Takeaways

• Four areas of AI assistance: Technical planning, codebase research, frontend development, and testing.

• 22% below planned effort: Seven workstreams completed in 762 recorded hours against 980 estimated hours, with five finishing under estimate.

• Engineering-led delivery: AI supported initial analysis and implementation, while developers retained responsibility for technical decisions and reviews.

• Evidence from one project: The results reflect two engineers working on a single project, measured against planning estimates rather than a controlled non-AI baseline.

Applying AI-Assisted Development to a Complex Production Environment

CodeLink's two-engineer team worked on a dental scheduling platform with integrations across multiple Practice Management Systems. Each workstream was handled by one engineer. The two engineers worked on different workstreams in parallel.

The application comprised three repositories: one NestJS backend and two ReactJS frontends for administrators and end users. 

The development roadmap covered payment integration, reporting, insurance workflows, performance improvements, and expanded testing.

Each workstream required engineers to navigate existing APIs, interpret business requirements, and research external services. AI was introduced to support this work, particularly during technical discovery, planning, and implementation.

How We Integrate AI Into the Software Development Lifecycle

Our AI-assisted development workflow used Claude Code as the primary AI coding agent, supported by Superpowers, a plugin providing reusable skills for structured development tasks.

The operating principle: AI produces the first draft; engineers make the final call.

We applied this model across four areas of the development process.

1. Technical Planning and Requirements Analysis

AI analyzed client requirements, researched existing system behavior, and drafted technical plans for developer review.

How responsibilities were divided:

• AI: Requirements analysis, codebase research, and proposed implementation approaches.

• Engineers: Requirements clarification, technical decisions, business logic, and edge cases.

Project example: Production Value and Show Rate

The workstream involved calculations related to practice revenue and appointment attendance. AI analyzed client requirements and examples, then proposed performance improvements for developer review.

This gave engineers a starting assessment to review. They then built the final calculation logic based on AI suggestions and checked the edge cases.

The workstream was completed in 80 hours against 120 planned hours, a difference of 40 hours.

2. Codebase Research and Technical Discovery

AI-assisted codebase research helped developers locate existing APIs and review technical documentation before implementation.

Project examples:

• Payment and Stripe integration: AI researched payment-flow architecture, technical documentation, and compliance considerations. Engineers evaluated the findings and finalized the implementation approach.

• Security fix: AI mapped existing APIs, allowing the developer to skip the initial codebase-discovery step. The fix required two recorded hours against an eight-hour estimate.

These examples show where AI supported technical discovery, reducing some of the preparation required before engineers could proceed with implementation.

3. Frontend Development and Integration

AI supported frontend development against existing APIs, with developers retaining responsibility for the APIs and reviewing generated interfaces.

Project example: Online Scheduling Report

The team used AI to compare tracking-service providers and build reporting interfaces, helping produce an earlier MVP for client feedback.

AI also supported frontend implementation for the payment and Stripe integration.

The two workstreams were completed below their original estimates:

• Online Scheduling Report: 160 actual hours vs. 240 planned.

• Payment and Stripe integration: 280 actual hours vs. 400 planned.

4. AI-Assisted Testing

The team used AI to generate test cases from developer instructions, supporting efforts to expand test coverage across existing components.

The process followed three steps:

1. Engineers provided instructions for generating test cases.

2. AI generated initial test cases.

3. Engineers reviewed each case before incorporation.

The test suite workstream required 64 recorded hours against 80 estimated hours.

Nevertheless, not every testing-related activity finished below plan. Separately, Jest framework setup required 16 hours against a 12-hour estimate.

Selecting AI Tools Based on Task Requirements and Cost

The team used Claude Code as its primary coding agent, supported by reusable development skills through the Superpowers plugin.

Model selection was based on task requirements and cost. Anthropic models delivered higher-quality outputs but at a significantly higher cost, making them better suited for detailed technical planning. Once the approach was established, the team explored lower-cost models for implementation, where its output quality was sufficient.

Total AI token expenditure across the seven workstreams was $1,152.

Data Security and Engineering Oversight

The team incorporated safeguards to manage source-code exposure, third-party AI access, and the quality of AI-generated outputs.

• Controlled data access: Claude Code sends prompts and the files or command outputs accessed during a session, rather than uploading the entire repository. The team configured deny rules to prevent AI from accessing sensitive files.

• Provider assessment: Before introducing third-party models to the project, CodeLink's AI Engineer researched the providers to inform model selection.

• Engineering review: All AI-generated code underwent developer review and pull request (PR) review before being merged into the codebase.

These measures helped the team integrate AI into development while maintaining control over sensitive information and code changes.

AI-Assisted Development Results

During June and August 2026, the team completed seven major development workstreams. 

The team recorded 218 fewer hours than originally planned, equivalent to approximately 22% below estimate. Recorded effort includes developer time spent interacting with AI tools, reviewing generated outputs, and implementing changes.

Automated test coverage also increased from 0% to 67.1%. After setting up Jest, the team used AI to generate tests for existing components, with engineers reviewing each test before incorporation.

Note: AI assistance varied by workstream, with partial use in the Insurance Flow, Production Value and Show Rate, and security fix.

Interpreting the Results

The measurements have several limitations:

• Planning estimates, not a control group: The 980 planned hours are the team’s own estimates. Some were made early in the project, when the team was new to AI and expected little help from it. Later estimates already included some AI use. So the baseline is mixed. It’s not a non-AI baseline.

• Limited measurement period: Figures cover seven workstreams completed in June and August 2026. Time spent on AI setup and learning was not tracked separately.

• Approximate figures: Some AI cost figures are approximate, including the payment integration cost (about $180).

• Insurance flow and related logic changes: During this workstream, the engineer also investigated client bugs and delivered two small extra workstreams.

The results therefore describe delivery performance under an AI-assisted workflow, not a verified 22% productivity improvement caused by AI.

What Didn’t Work

AI-assisted development also introduced challenges that required additional engineering effort.

• High model costs and incomplete outputs: The team used Anthropic's Opus model to analyze code flows when generating tests. This incurred approximately $300 in costs, and the model sometimes struggled to interpret application logic, continuing to process tasks without completing them.

• Frontend rework: AI-generated interfaces achieved approximately 80% alignment with Figma designs. Engineers had to refine the remaining implementation manually.

• Underestimated work: Jest framework setup and Insurance Flow exceeded their original estimates as additional issues emerged during development.

• Defects requiring attention: Insurance Flow had seven identified bugs, including two critical issues. Payment integration had three bugs, also including two critical issues.

• Review overhead: The critical vulnerability fix required just two hours of implementation, but approximately five additional hours of PR review.

These findings reinforce an important distinction: reducing implementation effort does not necessarily reduce total delivery effort. Model costs, output quality, debugging, and review time must also be considered when evaluating AI-assisted development.

Three Lessons for Enterprise AI-Assisted Development

1. Optimize the Workflow, Not Just Code Generation

AI in software development extends beyond generating code.

On this project, the team applied AI to requirements analysis, API discovery, documentation research, frontend implementation, and test creation.

These activities are part of engineering delivery and can consume substantial developer capacity.

The implication: Evaluate AI opportunities across the workflow, including the work required before implementation begins.

2. Maintain Clear Engineering Accountability

AI-generated plans, code, and tests require developer review.

Engineers retained responsibility for technical decisions, API implementation, business logic, edge cases, and acceptance of AI-generated outputs.

This approach positioned AI as an engineering support tool rather than an autonomous decision-maker.

The implication: Define responsibilities and review expectations before incorporating AI coding agents into delivery.

3. Measure Delivery Outcomes, Not AI Activity

More AI-generated code does not necessarily mean more effective software delivery.

Organizations should evaluate AI-assisted development using metrics that reflect engineering outcomes:

• Efficiency: Delivery effort, cycle time, and review overhead.

• Quality: Test coverage, defects, and production reliability.

• Cost: Model expenditure, setup effort, and ongoing operational costs.

• Predictability: Variance between estimated and actual effort.

Our project provides an initial comparison of planned and actual effort. Further measurement would be needed to assess AI's contribution to productivity, quality, and financial performance.

Integrating AI Into Production Software Engineering

The project illustrates how a lean engineering team can incorporate AI into established software development workflows, from technical planning and research to frontend implementation and testing.

For CodeLink, the priority remains high-performance software engineering, with AI applied where it can support delivery without transferring technical accountability away from engineers.

For CTOs and engineering leaders, the central consideration is how to integrate AI into existing delivery practices with appropriate review, operational controls, and measurable outcomes.

CodeLink

Founded in 2016

We partner with enterprises and institutions to turn complex technology challenges into reliable digital systems through expert software engineering, AI implementation, and disciplined delivery.