AI in Practice: How Engineering Teams
Use AI Without Losing Control

In other words, AI supports our engineers. It doesn’t replace them. 
Here are a few examples of how that works in practice.

Making Legacy Systems Understandable Again

One of the most common problems organizations face is legacy software. Many critical systems have evolved for years without clear documentation. Understanding how they work can take weeks of investigation.

Our teams have developed expertise in using AI agents that analyze existing codebases and extract key information such as:

• functional behaviors;
• system workflows;
• business rules embedded in the code.

From this analysis, AI generates initial documentation drafts, including functional specifications, API descriptions, and system data flows.

However, the process does not stop there. Engineers review and refine these outputs, ensuring they reflect real business processes and architectural decisions.

The result is faster documentation creation and a clearer understanding of complex systems, which helps teams safely modernize or extend existing platforms.

Bringing Structure to AI-Assisted Development

One challenge with AI-generated code is that it can easily become chaotic without clear guidance. To avoid this, our engineering teams follow structured workflows that guide AI interactions.

Instead of asking AI to simply “write code,” we start with specifications and architecture guidelines. AI helps generate drafts of documentation, technical designs, and implementation plans, but these artifacts follow a defined structure.

This spec-first approach keeps development consistent across projects and reduces ambiguity. The goal isn’t uncontrolled AI generation; it’s AI supporting disciplined engineering practices.

Expanding What Quality Assurance Can Cover

Quality assurance is another area where AI is creating new possibilities.

Traditionally, many testing activities require significant manual effort:

• writing test cases from user stories;
• creating test data;
• building automation scripts;
• identifying interface elements in applications.

AI can assist in generating test scenarios based on documentation or product requirements. These scenarios then become the starting point for automated tests, which QA engineers review and refine. What used to require several days of manual work can now be accelerated significantly.

More importantly, our teams can expand their testing scope to include areas that were previously difficult to cover due to capacity limitations and lower priority, such as usability checks, improved security, performance testing, or broader test coverage. This enables our teams to focus on deeper validation and quality strategy.

Why Human Oversight Still Matters

Despite its capabilities, AI still requires experienced professionals to guide and validate its outputs.

Senior engineers and architects play a critical role in ensuring that AI-generated artifacts meet enterprise standards for:

• security;
• scalability;
• maintainability.

AI accelerates engineering workflows, but accountability remains human. This combination of AI efficiency and engineering oversight allows teams to deliver faster while maintaining the quality standards our clients expect.

The Real Value of AI in Engineering

For many organizations, the biggest opportunity with AI is not replacing people. It’s amplifying the capabilities of experienced teams.

When we implement it responsibly, AI can:

• reduce repetitive work;
• accelerate delivery cycles;
• improve product quality;
• free engineers to focus on complex problems.
  

That’s the direction our teams have taken today: integrating AI into real engineering workflows while maintaining the discipline required for reliable software delivery. Because the reality of software development today isn’t just AI code generation but AI working alongside experienced engineers.

Another piece will follow, covering the impact we’ve had using AI and the results we’ve seen so far.

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.