Exoft has been supporting the development of a B2B SaaS platform for sales automation for several years. As the product evolved, so did our engineering workflows. We introduced AI-assisted development practices to speed up coding, testing, documentation, and other routine tasks. Beyond using ready-made coding assistants, our engineers built custom AI skills to automate multi-step development workflows. The result: less time spent on repetitive work, faster implementation, and more engineering capacity for complex tasks. However, developer always review and control AI-generated output for quality and security reasons.

About the Client

The client is a US-based B2B SaaS company operating in a competitive market where responding quickly to customer requests is key to retaining clients and attracting new ones. To stay ahead of competitors, the company needed to shorten development cycles, deliver requested features faster, and improve engineering efficiency without compromising product quality.

The Challenge: More Development Work, Less Time for Routine Tasks

Our client is developing a SaaS product with multiple integrations, complex business logic, and changing customer requirements. As the product expanded, the engineering team had to develop new functionality, maintain existing integrations, address performance issues, and meet growing security requirements.

Each change also comes with supporting work: writing tests, documenting decisions, preparing tickets, reviewing code, and getting changes ready for release.

Some of these activities are necessary but repetitive. Others require substantial engineering judgment and an understanding of the existing architecture.

We needed a way to speed up development without compromising code quality or leaving engineers to fix poorly understood AI-generated changes.

Our Approach: Automating Routine Engineering Work with AI

We gradually introduced AI into different stages of development. We initially used GitHub Copilot for code completion and assistance. As the available tools improved, our engineers adopted Claude Code and began developing custom AI skills to handle more complex workflows.

1. AI-Assisted Development and Architecture

Our engineers use AI to accelerate implementation, particularly when a task has clear requirements or follows familiar patterns.

How we use it:

  • Generate initial code structures and feature implementations based on engineer-defined requirements.
  • Discuss architecture options, design patterns, and potential trade-offs before implementation.
  • Analyze existing code and help investigate bugs.
  • Break complex changes into smaller tasks that can be implemented and reviewed individually.

This approach reduces time spent writing predictable code while keeping architectural decisions with the development team.

2. Faster Test Creation and Verification

Writing automated tests can take almost as much time as implementing the functionality they cover. We use AI to generate initial test cases and test code, allowing engineers to move more quickly from implementation to verification.

How we use it:

  • Generate tests for new functionality.
  • Create initial test coverage based on existing code.
  • Review generated tests and identify missing scenarios.
  • Assist with analyzing defects and investigating failures.

One of our engineers reported that writing tests for a feature previously took another one or two days after development. With AI assistance, generating an initial set of tests can now take approximately one or two hours.

3. Custom AI Skills for Development Workflow Automation

Beyond code generation, we developed custom AI skills to automate tasks surrounding development. These skills combine AI analysis with predefined scripts, templates, and multi-step workflows. Instead of manually preparing each artifact, engineers can trigger a sequence of operations after completing their work.

The workflows cover:

  • Task management: Creating structured tickets and epics with clearer requirements and descriptions.
  • Code analysis: Reviewing implemented changes and collecting information needed for documentation.
  • Commit preparation: Organizing changes and preparing descriptive commit histories.
  • Merge requests: Generating merge request descriptions with implementation details.
  • Technical documentation: Preparing architecture descriptions, design explanations, and bug-fix documentation.
  • Incident documentation: Recording what happened, what was changed, and why.

One of our engineers built a custom workflow containing approximately 12–13 steps. It uses Python scripts and structured instructions to carry out the operations in sequence while limiting unnecessary AI model usage. Work that previously took 30-40 minutes, and occasionally several hours, can now be completed in approximately 15 minutes.

Human Oversight Remains Central to Our Process

AI can produce code quickly, but it doesn’t always understand the full context behind an engineering decision. Our team has found that insufficient context can lead to implementations that take longer to correct than writing the code manually.

That’s why engineers remain responsible for the architecture, implementation quality, testing, and final decisions.

In practice, this means developers:

  • Define requirements and architectural constraints before asking AI to implement a solution.
  • Review and adjust AI-generated code.
  • Validate generated tests and extend coverage where necessary.
  • Assess security, performance, and integration implications.
  • Make the final decisions about what is ready to merge and release.

Results: Faster Development Without Giving Up Engineering Control

Introducing AI-assisted development has helped the team reduce the time spent on repetitive engineering activities. The measurable results include:

  • 40% faster development
  • Initial test generation reduced to 1–2 hours
  • Development administration reduced in half
  • More consistent engineering documentation
  • More time for complex engineering work

These improvements help the team handle changing requirements and deliver product updates with less manual overhead. We also sped up software delivery for the client, enabling them to produce more in-demand features faster than their competitors.