From AI Adoption to Agentic Engineering: How Our Teams Are Using AI and What It’s Actually Changed

The Question We Kept Asking Ourselves

Most companies adopting AI today are asking “How fast can we go?” We kept asking a different question: “How do we make sure we’re comfortable showing a client exactly what we did and how we did it?”

That distinction matters. It’s the difference between chasing velocity and building something defensible. Between vibe coding and agentic engineering.

Our answer was to design adoption from the inside out, discipline by discipline, use case by use case, and only expand what was proven to work.

Development: Owning the Process, Not Just the Output

Our development teams adopted a spec-first, phased delegation model. 

The short version: engineers write the specification, challenge it with AI, delegate implementation in controlled chunks (approximately 30-50 lines at a time), and review every line before it moves forward.

The human stays in the architect’s seat. AI handles the engine room.

What changed in practice:

• Legacy system documentation, which used to take weeks of investigation, can now be accelerated significantly. AI agents analyze codebases and extract functional behaviors, workflows, and embedded business rules. Engineers then review and refine, not start from scratch.
• Code reviews are faster and more thorough. Engineers pre-flight their own PRs by feeding diffs to AI before opening them. It catches debug logs, missing validations, and pattern violations before a human reviewer ever sees the code.
• Testing has become much easier to fit into the development flow. Unit tests that once took 15–20 minutes manually now take around 3 minutes with AI assistance. Integration tests: from 20–30 minutes to roughly 4 minutes. The time constraints around testing no longer apply.

AI is now involved in a significant part of the code our teams produce. What hasn’t changed is ownership. Every AI-assisted line is read, understood, and owned by the engineer who commits it. The tool drafts. The engineer decides.

QA: From Manual Coverage Gaps to End-to-End Automation

Our QA engineers began experimenting with AI tools about a year and a half ago. The end-to-end automation system has been live for the past few months, and the impact is already visible across delivery speed, coverage, and consistency.

The architecture built by our QA Discipline Lead connects multiple AI agents across the full sprint lifecycle. A product owner creates a story, the developer implements it, and QA feeds it into Claude with full context. The system generates test cases, stores them in Azure DevOps using a MySQL MCP database enriched with test data, maps web elements via Playwright MCP, and produces automation scripts ready for human review and execution.

While the underlying system is complex, the experience for QA engineers is straightforward: describe what needs to be tested, review what the system produces, validate, and run.

What has changed is not just efficiency, but what is now possible. 

• Test case generation is now consistent, structured, and aligned with requirements, reducing gaps and rework.
• Test data preparation has shifted from a manual bottleneck to a largely automated, reliable process.
• Web element mapping is handled automatically, eliminating one of the most time-consuming steps in automation.
• Automation scripts are generated at a high level of quality, requiring only targeted human validation.

More importantly, teams can now cover areas that were previously difficult to address within sprint constraints: usability checks, performance scenarios, security validation, and broader regression coverage. These areas were not ignored before, but often deprioritized due to effort and time limitations.

Here’s what our QA Discipline Lead, adds:

A process that previously required several hours or even days can now be completed within a single day, with most of the effort focused on reviewing AI-generated outputs and applying human judgment where it adds the most value.

What “Healthy AI” Looks Like

Both software development and QA teams share a few consistent principles:

• Structure before generation. Neither team lets AI run free. Development starts with a spec. QA starts with documented test scenarios. AI fills in the implementation, not the thinking.
• Human review is non-negotiable. AI pre-flights code; engineers commit it. AI generates test scripts; QA validates and runs them. The accountability stays with the person, every time.
• Metrics and documentation. Both software development and QA teams have internal guidelines, documented processes, and regular review sessions. The QA engineers run weekly one-hour sessions with the QA Discipline Lead — not to push more AI usage, but to share what’s working, what isn’t, and how to use it better.
• Expansion only where it makes sense. We’re not using AI because it’s available. We’re using it in the places where it demonstrably removes friction, accelerates coverage, or frees up engineers to do the work that actually requires their judgment.

Why This Matters for Clients

The visible output, like faster delivery, broader test coverage and cleaner documentation, is only part of the story. 

The more important change is what our teams can focus on now. 

• When boilerplate is automated, development engineers spend their time on architecture, security, and system design. 
• When test generation is handled, QA engineers spend time on deeper validation, edge cases, and quality strategy.

Faster delivery used to mean accepting some quality trade-off.

That’s no longer the equation we’re working with.

Expert Network is a software factory, not an AI lab. 
Our job is to deliver reliable, maintainable software. AI is one of the ways we do that better.