Skip to content
AfiOps, AI & IT Solutions
Contact us
AI-Assisted Engineering

For delivery teams moving past vibe coding

AI that writes, tests and reviews code — with a human at every gate.

We build and run AI-assisted engineering systems inside real delivery: test design, multi-agent SDLC pipelines, spec-driven code generation, codebase audits, MCP servers and RAG. Every output is traceable, every decision is logged, and nothing merges without a person saying yes.

Where teams start: AI stuck in demos · tests that miss acceptance criteria · legacy code nobody can specify · generated code nobody trusts · no audit trail for AI decisions

Book a free 45-min AI engineering reviewCheck your SDLC in 2 min

45 minutes with an engineer who built these systems: your SDLC, where AI fits, what to automate first. No sales team.

  • 48

    specialist agents in one agentic modernization engine

  • 100%

    match with hand-written production code on two generated streaming jobs

  • 12

    gated agent skills in a spec-driven code generator

  • 426

    unit tests behind an AI-assisted QA framework

  • 310

    versioned data contracts governed in a Git registry

Industries we have shipped AI engineering for

  • Fleet telematics & mobility

  • Automotive

  • Accounting & ERP software

  • Business SaaS data platforms

  • Mining & industrial IoT

  • Industrial manufacturing

  • Professional services

Practices

What we build and run

Six practices, one standard: AI output must be traceable, reviewable and safe to ship.

01

AI-assisted quality engineering

Acceptance criteria in, reviewed and scored test cases out, uploaded to test management with a full audit trail.

  1. Story
  2. Test design
  3. AI review
  4. Test management

Examplea fleet telematics platform with 37+ modules, 5 environments and 2 regions.

  • Claude Code

  • GitHub Copilot

  • Jira REST

  • TestRail API

  • Python

02

Agentic SDLC engines

Multi-agent pipelines that take a backlog item to a review-ready pull request, with plan gates, review councils and learning loops.

  1. Ticket
  2. Spec
  3. Plan
  4. Build & test
  5. PR

Examplemodernizing a legacy C++ accounting product to .NET MAUI and PostgreSQL with 48 agents.

  • Claude Code

  • Agent SDK

  • Spec Kit

  • GitHub Actions

  • Notion

03

Spec-driven code generation

Data contracts become versioned specifications, then gated code, then independent reviews against both the spec and production code.

  1. Contract
  2. SDD
  3. Trace matrix
  4. Code
  5. Review

ExampleKafka-to-S3 Flink streaming jobs for a business SaaS data platform.

  • OpenAI Codex

  • Apache Flink

  • Kafka

  • DuckDB

  • Parquet

04

AI codebase assessment

Expert-persona agents audit a codebase on 10 engineering dimensions and write scored HTML reports with a confidence method.

  1. Repo
  2. 10 lenses
  3. Evidence
  4. Scored report

Examplea mining operations platform, plus a consolidation study of two industrial platforms.

  • Claude Code skills

  • MCP

  • PlantUML

  • Chart.js

  • OWASP ASVS

05

MCP servers, RAG & knowledge graphs

Business APIs exposed as MCP tools with in-host UI widgets; vector and temporal graph retrieval over code, documents and requirements.

  1. API
  2. MCP tools
  3. Widgets
  4. Assistant

Exampleabout 20 fleet-management MCP tools with voice input, rendered inside the AI host.

  • NestJS

  • MCP Apps

  • Weaviate

  • Graphiti / Neo4j

  • AWS Bedrock

06

Enablement & AI engineering practice

Training series, curricula, toolkits and talks that move teams from autocomplete to governed agentic engineering.

  1. Vibe coding
  2. Instructions
  3. Skills
  4. Agents
  5. Orchestration

Examplea 5-week Copilot CLI curriculum with 25 slide sessions and hands-on labs.

  • Copilot CLI

  • Claude Code

  • ADR / C4

  • Threat modeling

How it fits together

From where most teams start to what we build

Typical starting point

Requirements

Logic in people's heads

stories without numbered ACs

AI use

Chat and autocomplete

each developer their own way

Review

No audit trail

nobody can say why AI changed it

What we build

Source of truth

Ticket and ACs

Data contracts

versioned · in Git

Agents

Spec · plan · build · test

shared skills, not prompts

Gates

Deterministic checks

coverage · build · drift

Human merge

Evidence

Decision log

transcripts · trace matrix

From AI as a chat window to AI as part of the delivery pipeline: specs it can read, agents with one job each, gates a script checks, and a person who says yes before anything merges. The case studies below show it in practice.

Selected work

Shipped, measured, and honest about the gaps.

Client names are withheld. Industry, architecture and technology are not.

Fleet telematics & mobility

6 skills · 426 tests

104 commits in 5 months · v1.3 in production use by QA

AI-assisted test design and review framework

A knowledge layer, not a test suite. It turns a Jira story into reviewed, scored test cases and uploads them to test management. It runs in Claude Code and GitHub Copilot from one source of truth.

  • Six skills, each with a Copilot agent twin: design, review, upload, case 360 report, live preview and a design-then-review chain.
  • Deterministic coverage gate fails when an acceptance criterion has no case or a conflict has no human decision.
  • Distribution as two npm packages with an install verifier, three run modes and a self-bootstrapping Python environment.
  • Target benefit: design time from 2 to 4 hours down to 15 to 30 minutes. This is a goal, not yet a measurement.

  • Claude Code

  • Copilot agents

  • Python

  • Jira

  • TestRail

  • npm

Read the full case study

Accounting & ERP software

48 agents · 19 commands

9 workflows · 21 CI jobs · ~868,000 tool calls analyzed

Agentic modernization engine for a legacy product

Moves a legacy C++ accounting product to .NET MAUI and PostgreSQL. A tech-lead orchestrator ships one story at a time and loops until the dependency graph is empty.

  • Spec extraction in 9 stages, among them behavior, data and UI lenses, a reconciler, an architecture mapper, a spec auditor and a backlog publisher.
  • Dev loop: architect plans, a plan validator gates it, developers build, QA agents test, a five-seat review council checks architecture, security, legacy parity, UI accuracy and memory leaks.
  • Learning loop turns mistakes, gaps and defects into rule changes, with a lesson journal to catch repeats.
  • Cost-aware model mix: Haiku for mechanical checks, Sonnet for most work, Opus only for the plan gate. Tool error rate 2.1%.

  • Claude Code

  • Opus / Sonnet / Haiku

  • .NET MAUI

  • PostgreSQL

  • Appium

  • Notion

Read the full case study

Automotive

6 stages · 4 run modes

Built in 30 days · ticket to review-ready PR across repos

Spec-driven agentic AI-SDLC pipeline

A ticket flows through triage, spec, plan, build and test, PR and CI, and merge. It produces a review-ready PR in every repository the ticket touches. Run modes range from autonomous to fully human-gated.

  • Machine-level toolkit with init, update and uninstall scripts. Its skills implement features, open merge requests, sync docs, refresh guidelines and index repos.
  • Author, judge and mechanic agents separate writing, evaluating and fixing.
  • Guardrails: pre-commit hook, doctor script, a cross-repo index to decide scope, and guidelines refreshed from Confluence.
  • Spec Kit brownfield setup on a Spring Boot and Angular target, with about 20 spec folders.

  • Spec Kit

  • Claude Code

  • Spring Boot

  • Angular

  • Confluence

  • GitLab MR

Read the full case study

Business SaaS data platform

100% reference accuracy

On the two direct jobs · 28 generated entity classes · 15 human-approved decisions on the hardest job

Spec-driven generation of streaming data pipelines

Twelve Codex skills turn a resolved data-contract pipeline spec into a versioned SDD and then into Java Flink jobs. The jobs read CDC events from Kafka, keep state in DuckDB and write tenant-partitioned Parquet to S3.

  • Two direct current-state jobs matched the hand-written production jobs at 100% on behavior and output shape.
  • A five-source tenant recompute job needed 15 decisions, each with an options analysis and an explicit approval, before code generation.
  • Drift reconciliation passed both human gates with zero residual drift.

  • OpenAI Codex

  • Java 11

  • Managed Flink

  • MSK Kafka

  • DuckDB

  • S3 / Parquet

Read the full case study

Business SaaS data platform

310 contracts · 206 tests

7 source services · PR-gated breaking-change detection

Data contract registry with an agent delivery pipeline

A Git catalog of shared data. It holds YAML contracts, DuckDB SQL mappings and manifests, plus generated pipeline specs that are hashed for debounce, idempotent dispatch and drift checks.

  • CI gate: validates every artifact, classifies changes as additive or breaking, blocks unversioned breaks, notifies affected consumers in Slack.
  • Agent pipeline design: a dispatch reaches an integration repo, a write agent opens a PR and a review agent checks it. It allows 3 retries, then escalates, and only a human merges.
  • Dual runtime: GitHub Copilot coding agent or Claude Code, switched by one variable and driven by a single canonical skill file.
  • In a dry run the write agent refused to guess. It flagged SQL that projected 6 columns into a 26-column sink instead of opening a plausible but wrong PR.

  • Python

  • DuckDB

  • GitHub Actions

  • AWS CDK

  • act

  • Slack

Read the full case study

Mining & industrial IoT · Manufacturing

10 dimensions · 11 skills

7 scored reports per platform · 4 consolidation options compared

360° AI codebase assessments

Persona-based skills audited a mining operations platform and three other products. Each audit produced scored reports from 0 to 10 on ten dimensions, among them architecture, code quality, tests, CI/CD, performance, data, DevOps, monitoring and security.

  • Consolidation study comparing two industrial platforms across minimal, hybrid, integration and migration options, with an executive deck.
  • Security lens uses OWASP ASVS and IEC 62443. Diagrams come from PlantUML, including ERDs and sequence charts.
  • Companion VS Code extension with configurable AI providers and Jira and Confluence integration.

  • Claude Code

  • MySQL MCP

  • PlantUML

  • Chart.js

  • VS Code API

Read the full case study

Fleet telematics & mobility

~20 MCP tools

Hackathon build · voice to action

Conversational fleet operations through MCP Apps

A NestJS MCP server exposes drivers, vehicles, jobs and roles as tools, plus prompt flows such as job reassignment. Tools return UI metadata, so Vue 3 widgets render inside the AI host. A faster-whisper server feeds a browser voice assistant.

  • MCP

  • NestJS

  • Vue 3

  • faster-whisper

Professional services

Graph RAG

RFPs and transcripts to traceable requirements

Requirements copilot and knowledge base

Turns RFPs and meeting transcripts into requirement hierarchies with temporal graph RAG. A FastAPI knowledge service runs vector search with HyDE query rewriting and serves an authenticated MCP server with OAuth and rate limiting.

  • Claude on Bedrock

  • Agent SDK

  • Graphiti

  • Neo4j

  • Weaviate

  • Titan v2

  • SQS FIFO

  • Streamlit

Read the full case study

Telemetry analytics · Delivery tooling

NL → SQL · Review agents

Serverless chatbot · scheduled and CI-triggered reviewers

Telemetry chatbot and reviewer agents

An LLM writes SQL through LangChain and LangGraph and answers with text, tables or charts on a serverless AWS stack. Separate agents review Jira tickets on goal, description, solution and ACs on a CronJob schedule. Others review pull requests for code, Java, TypeScript and security.

  • LangChain

  • LangGraph

  • FastAPI

  • Lambda / SQS

  • Kubernetes

  • Helm

  • Terraform

  • Rovo MCP

Case studies are anonymized and named by industry only. Figures come from project repositories and history. Benefit targets are labeled as such.

Inside the systems

How two of them actually work

The mechanics, rules and evidence behind the QA framework and the spec-driven generator.

AI-assisted QA framework

  1. 1 · Design

    story → test cases

  2. 2 · Review

    score, fix, re-check

  3. 3 · Upload

    dedup, write, link back

  4. + Preview

    live browser viewer

  5. + 360 report

    one-case snapshot

Design: 10 steps from story to test cases
  • Connectivity first: issue tracker and test management must both pass before any work starts.
  • Context fetch through REST: the story, linked items, comments in time order, images and documents (Word, Excel, PowerPoint, PDF) with extracted text, within size limits.
  • Two-part generation: an analysis (feature context, 10-lens table, scenario and risk matrices, requirement inventory, conflict table), then test-management YAML.
  • Case shape: 3 to 6 steps, Gherkin-style prerequisites, verifiable results, bilingual UI text, P0 to P2 priority and a “covers” list tying each case to ACs.
  • Coverage gate runs twice and fails on any uncovered AC or undecided conflict. It warns on placeholders, overlaps and unused images.
  • Open items are asked, not reported: each one becomes a question that carries the case context.
Review, scoring and upload
  • Overview pass: a 7-check scorecard, an AC coverage map, missing negatives and boundaries, traceability, and the priority distribution.
  • Per-case pass scores 1 to 5. The in-agent mode uses about five times fewer tokens than fanning out to subagents.
  • Two scores, never combined: a design score from counted inferences and a review score. Any score under 5 explains why and what would reach 5.
  • Gate: an average of at least 4.0 and no blocker. Mechanical fixes apply automatically, and judgment calls go to the user.
  • Upload: each section is confirmed one by one, a dry-run table comes first, dedup is by ID or normalized title, and IDs are written back. Deletions are never allowed.
10 coverage lenses and the 10-stage QA SDLC

Each story is checked against happy path, negative input, boundaries, permissions, state transitions, concurrency, cross-module effects, recovery, performance and accessibility. Each lens is marked covered, partial or gap.

  1. 1

    Epic & story

  2. 2

    DoR gate

  3. 3

    Test design

  4. 4

    Case review

  5. 5

    Automation

  6. 6

    PR review

  7. 7

    Run & triage

  8. 8

    DoD gate

  9. 9

    Release test

  10. 10

    Live

Stages 3 and 4 are in use. The other stages are on the roadmap, with automation scaffolding and failure triage from CI logs next.

Audit trail, viewer and distribution
  • Per-story output tree with deliverables and logs for the AI, the tracker and the uploader.
  • Append-only conversation log with a token table, timeline, decisions and the full dialogue, plus a per-run transcript of every tool call.
  • Step markers are recorded by a script that refuses a skipped step.
  • Offline HTML viewer served on loopback. It shows AC coverage, both scores, step images and the decision trail, and can make a frozen, checksummed snapshot to share.
  • One source, two engines: a publish script rewrites paths for Claude and Copilot packages, and an install verifier does not trust npm’s exit code.

Spec-driven pipeline generator

  1. 1 · Generate / clone

    spec → config + SDD

  2. 2 · Review SDD

    trace intent

  3. Gate

    blocking → human

  4. 3 · Implement

    trace matrix first

  5. 4 · Code vs SDD

    conformance

  6. 5 · Code vs prod

    accuracy %

  7. + Reconcile

    two human gates

Why specifications, not prompts
  • Valid is not correct. Registry checks passed every manifest and contract. They proved shape, not topics, keys, types, deletes or state transitions.
  • No universal donor. Ten pipelines split into three runtime families: direct current-state, partitioned merge and snapshot recompute. Reusing one template scored 85 to 90% for the first family and 60 to 65% overall.
  • Authority order: registry intent, then human-approved decisions, then approved SDD and configuration, then shared-core facts. Existing code is evidence, never authority.
The SDD workspace and decision log
  • Seven artifacts per version: constitution, source, spec, plan, tasks, acceptance and decision log. A canonical config.yaml holds provenance with SHA and every runtime value.
  • Config domains: Kafka (CDC, ordering, topic, group), DuckDB (schema, upsert, null-update and delete order), Flink (buffering, timers, cache, telemetry), S3 (path, compression, rehydration, retry, crash consistency), registration and code identity.
  • Decision log is the only place for questions and approvals. Each open decision carries an options analysis with pros, cons, consequences and a labeled recommendation, and a recommendation is never an approval.
  • Append-only history in four sections: SDD review, implementation trace matrix, code review and activity log. A local viewer reloads when an agent edits the file.
Codex agent design
  • Skill contracts with trigger descriptions, plus agent cards that set the display name and default prompt for each Codex agent.
  • Workflows as staged prompts. Each numbered stage declares its own read-only, read-write and prohibited paths and runs as a fresh context. Git history and earlier sessions are off limits.
  • Checkpoints before and after every stage show inputs, allowed writes, driving facts, changed files and checks. Progress is reported at least every 30 seconds.
  • Implementation gate: a full trace matrix is written before any code edit, down to each retry status and projection position. Then come Spotless, Maven test and package.
  • Destructive actions need the exact prompt “May I delete <target>?” and a fresh yes.
  • Reconciliation: a hashing snapshot helper classifies drift across contracts, SDD, entity code and shared core. Changes pass two human gates, one for the spec and one for production code.
  • 360 session report records verbatim prompts, reasoning, commands and outcomes, and labels every token figure as an estimate.

Guardrails

How we keep AI honest

The same rules run through every system we build.

One source of truth

The ticket defines the ACs, and the contract defines the data. Linked material can add detail but never adds scope.

Ask, don’t guess

Every ambiguity becomes a question with options and consequences, one at a time, always with a defer option.

Deterministic gates

Coverage, sections, media, builds and drift hashes are checked by scripts, not by the model’s opinion.

Least privilege by design

Write agents cannot merge, and review agents cannot write. Token scopes and per-stage sandboxes enforce it.

Never destructive

No deletions in systems of record. A timestamped backup comes before any overwrite, and re-runs are idempotent.

Everything explains itself

Every score has a basis, every decision has an approver, and every run leaves a transcript.

Cost-aware models

Small models do mechanical checks, mid-tier models do most work, and frontier models are kept for plan gates.

Honest metrics

Targets are labeled as targets and estimates as estimates. Open gaps stay visible.

Technology

The stack behind the work

Tools we have used in shipped systems, not a wish list.

AI assistants & agents

  • Claude Code

  • GitHub Copilot (CLI, agents, coding agent)

  • OpenAI Codex

  • Claude Agent SDK

  • Copilot code review

  • claude-code-action

Models

  • Claude Opus · Sonnet · Haiku

  • Claude on AWS Bedrock

  • OpenAI models

  • Titan v2 embeddings

  • faster-whisper

  • Local CPU LLM endpoints

Agent frameworks & methods

  • GitHub Spec Kit

  • Spec-driven development

  • LangChain

  • LangGraph

  • Skills & instruction files

  • Hooks

  • HyDE

Protocols & integration

  • Model Context Protocol

  • MCP Apps widgets

  • OAuth

  • Jira & Confluence REST

  • Atlassian Rovo MCP

  • TestRail API

  • Slack

  • repository_dispatch

Retrieval & knowledge

  • Weaviate

  • Neo4j

  • Graphiti temporal graph

  • Vector search

  • Document ingestion (MD, PDF, DOCX)

Quality & CI

  • Cucumber

  • Selenium

  • REST Assured

  • Appium

  • pytest

  • JUnit

  • GitHub Actions

  • Jenkins

  • CodeQL

  • OWASP ASVS · IEC 62443

Two minutes, no email required

How ready is your delivery for AI agents?

Six questions; “Not sure” is a fine answer. You get the score and what to fix first straight away. We keep your answers without your name or email, to improve the check, and if you then contact us from this tab, we attach them so the engineer can prepare.

Specification

Question 1 of 6

Do your stories have explicit, numbered acceptance criteria?

Filling in as you answer

Specification

—

Testing

—

AI usage

—

Governance

—

Delivery

—

Knowledge

—

Why engineered AI

Governed agents beat clever prompts

What changes when AI is built into the SDLC as a system, not used as a chat window.

AspectEngineered agentic SDLCAd-hoc vibe codingCopilot licenses onlyNo AI
Source of truthTicket and contract, enforced by gatesWhatever is in the promptDeveloper judgmentDeveloper judgment
AmbiguityLogged decision with options and approverSilently guessedDepends on the personMeetings
Audit trailTranscripts, trace matrix, decision logNoneCommit historyCommit history
ConsistencyShared skills and rubrics across teamsVaries by sessionVaries by personVaries by person
SafetyLeast-privilege agents, no deletes, human mergeFull accessHuman reviewHuman review
Cost controlModel tiering, debounce, retry capsUnboundedFlat licenseEngineer hours

How to start

Know where AI pays off first.

Start with a free review, then pick a fixed-scope engagement.

Free 45-min AI engineering review

  • For: engineering and QA leads who want AI in delivery, not in demos.
  • Bring: one real story, your repo layout and your current tools.
  • You leave with: the two or three workflows to automate first, and the guardrails they need.
  • No obligation.

Engagement process

  1. 1 · Assess

    SDLC, codebase, data

  2. 2 · Pilot

    one workflow end to end

  3. 3 · Scale

    skills, agents, CI

  4. 4 · Operate

    metrics, learning loop

2 weeks

Agentic SDLC Assessment

We map your lifecycle stage by stage and score where agents add value. You get a gated roadmap with costs and risks.

Fixed price · ask on the call

1 to 2 weeks

360° AI Codebase Audit

Ten engineering dimensions, scored 0 to 10, with evidence, diagrams, a security lens and an executive summary.

Fixed price · ask on the call

4 to 6 weeks

Agentic Pilot

One workflow taken to production with skills, gates and audit trail, for example test design, story to PR, or contract to pipeline.

Fixed price · ask on the call

Let’s look at your SDLC together.

45 minutes with an engineer who has shipped agentic systems. No sales team.

Book a free 45-min AI engineering reviewSee the case studies