Experimenting with AI in delivery

We recently partnered with Travelopia to explore how AI can enhance software delivery.

Using a disciplined blend of engineering fundamentals and AI-driven delivery practices, we built a system that evaluates the characteristics of lead enquiries, determines eligibility and auto-assigns them to a consultant if they are not already claimed. The solution also provides a user interface to manage consultants and oversee the entire lead lifecycle.

What is AI in delivery?

AI in Delivery is a software development approach that strategically integrates AI tools, particularly large language models (LLMs), throughout the delivery lifecycle in order to enhance productivity and quality.

In this context, it means using AI to generate code, tests, documentation, and stakeholder reports, while humans remain in control of architecture, design, and ensure overall quality.

Unlike “AI-driven” approaches, where AI makes key decisions, AI in Delivery positions AI as an accelerator, combining the speed and scale of AI code generation with the critical thinking and domain expertise of human engineers.

Good software engineering practices still matter

The term “vibe coding” relates to the rapid creation of prototypes, or even full production builds, almost exclusively created by AI with minimal human intervention.

There are certainly some impressive demos of entire applications created in this way. However, our experimentation highlighted that production-grade applications still require strong software engineering fundamentals, even when leveraging AI.

In our experiment, the vast majority of our code was AI-generated, yet we found that the quality of the outcome depended heavily on our discipline around architecture, design, and standards.

Our hybrid approach

To make the most of AI while ensuring maintainability, we adopted a hybrid delivery model:

1. Human-driven architecture
   1. System design and key decisions made by engineers, not AI
   2. Critical decisions made based on business requirements
   3. Established clear boundaries between system components
2. Structured decomposition
   1. Services broken down into well-defined microservices and Lambda functions with single responsibilities
   2. Created detailed interface definitions between components
   3. Designed data models that enforced business rules at database level
3. Clear standards and patterns
   1. Coding standards tailored to each language/framework
   2. Exemplar code snippets shared for LLMs to follow
4. AI as an implementation partner
   1. AI used primarily for implementation tasks
   2. Engineers supplied detailed context and reviewed output against standards

This approach allowed us to scale delivery with AI while preserving system clarity and quality for future teams.

Starting from the foundation made a difference

Stakeholders naturally wanted to see the user interface early. However, we prioritised the core system architecture before visual development. This decision ensured a stable foundation that could support rapid UI iteration later.

Core components we focused on

• A robust lead scoring algorithm with well-defined evaluation criteria
• A consultant matching service with configurable rules
• A secure data layer with validation and error handling
• A clean API layer, supporting multiple front-end options

By decoupling business logic from presentation, we reduced regressions, accelerated feature delivery, and enabled more effective AI code generation.

Benefits we observed

Prioritising the foundation before the interface delivered clear advantages:

• Reduced regression issues – UI changes rarely impacted core logic.
• Faster feature delivery – New UI features could be added in hours rather than days.
• More efficient testing – Core logic was validated independently of the interface.
• Higher-quality AI output – Well-defined API contracts enabled more precise prompts for generating UI components.

Even with AI accelerating development, the principle of separation of concerns proved essential. LLMs consistently produced better results when working within clean architectural boundaries rather than attempting to handle business logic and presentation at the same time.

Documentation matters

Agile often gets misinterpreted as having ‘no documentation’. In reality, it promotes ‘just enough’ documentation to guide delivery. With the introduction of AI, we found documentation even more critical for:

1. Guiding AI
   1. Well-documented APIs and rules led to more accurate code generation.
   2. Architecture diagrams allowed the creation of context-rich prompts.
   3. Detailed business rules enabled more accurate implementations.
2. Preserving decision rationale
   1. Recording design choices to ensure consistency.
   2. Documenting key decisions in ReadMes and PRDs.
3. Onboarding new developers
   1. Documentation enabled rapid ramp-up without lengthy handovers.
   2. New developers were able to contribute effectively from day one using only the documentation provided.

Rethinking Test-Driven Development in the age of AI

Test-Driven Development (TDD) brought clear benefits at the outset, forcing clarity around requirements, enabling refactoring safety, and providing fast feedback. However, we also uncovered challenges when pairing TDD directly with AI.

Where AI excelled

• Generating comprehensive test suites for new features.
• Creating detailed test cases covering edge conditions.
• Producing tests with clear, descriptive names.
• Following established patterns for similar components.

Where AI created challenges

• AI often misunderstood the intent of a test whilst processing an update.
• When confronted with failing tests, AI would:
  • Not address the underlying issue and change assertions to allow a test to pass.
  • Add mocks or stubs that circumvented testing needs.
  • Create unnecessary tests.
  • Remove validations to eliminate errors.

Our adapted approach

To adapt to these challenges, we developed a modified approach that can:

• Capture lightweight test specifications upfront, outlining key scenarios and acceptance criteria.
• Implement functionality with AI assistance.
• Create comprehensive tests post-implementation.
• Use AI to extend coverage with edge cases.

This approach maintained quality while reducing friction between TDD and AI workflows.

The power of prompting

AI output quality is only as strong as the input it receives. Through experimentation, we tested a variety of prompting techniques and found patterns that consistently produced good results.

The power of Example-Driven Development

We found that providing a few well-chosen examples dramatically improved the quality of AI-generated code. While zero-shot (no examples) and one-shot (single example) prompting offered some value, they often produced inconsistent results. In contrast, few-shot prompting (using multiple examples) consistently delivered code that needed minimal revision.

By showing the AI snippets that reflected our standards, such as how we structure components, write service logic, or handle errors, the generated output closely matched our patterns. This approach not only reduced rework but also accelerated tasks such as adding new endpoints to microservices or building new UI pages.

Our few-shot method

Our refined few-shot method:

• References existing files to illustrate our standards when requesting new code from AI tools like Cursor.
• Provides context around systems, requirements and instructions.
• Allows iteration of requests using examples of previous successful AI-generated tests.

This technique minimised rework, ensured style consistency, and improved accuracy, even on complex features.

Key takeaways

This experiment confirmed that AI accelerates delivery, but engineering discipline ensures success. The most effective model is one where humans and AI work in tandem, each playing to their strengths. We’ve learned that we should:

• Maintain strong engineering fundamentals
• Prioritise foundational architecture before UI development
• Treat documentation as a critical enabler, not an afterthought
• Adapt testing strategies to align with AI’s strengths
• Use few-shot prompting for reliable, high-quality code generation

Closing thoughts

AI in Delivery is not about replacing engineers, it’s about empowering them. By combining AI’s speed with human judgment and structure, we created a system that is not only functional but also maintainable and adaptable. This system has been in production and successfully serving real customers for the last quarter, handling approximately 5,000 leads per month with zero priority issues.

As AI continues to evolve, so too will the practices that guide it. Teams that embrace both innovation and discipline will be best positioned to unlock its full potential.

About the authors

Prasanth Jayaprakash is a lead engineer with over 16 years of hands-on experience across backend and frontend engineering. He partners with top-tier teams to deliver resilient, scalable systems aligned to business strategy. Prasanth’s current focus is applying LLMs throughout the SDLC – requirements gathering, code and test generation, documentation, and deployment – while maintaining architectural design and critical decision-making through his own expertise. He uses Generative AI to tackle real business problems and drive measurable outcomes.

Sathya Dhanabal is a software engineer with experience in Java, Scala, and scalable system design. Lately, he has focused on AI-augmented delivery, integrating large language models into the software development lifecycle to accelerate design, coding, and documentation. Sathya is passionate about bridging disciplined engineering practices with emerging AI capabilities to help teams deliver high-quality software faster.

Disclaimer

This blog is a record of our experiments and experiences with AI. It reflects what we tried, learned, and observed, but does not represent Equal Experts’ official practices or methodologies. The approaches described here may not suit every context, and your results may vary depending on your goals, data, and circumstances.