Skip to content

Architecture Assurance

An independent check on your architecture, and guardrails that keep the build to it

We review proposed designs and live systems, act as design authority on programmes others deliver, and review AI agent architectures. Where the code is written with AI tools, we turn the agreed architecture into Claude skills and automated checks that hold on every change.

Architecture assurance from Talk Think Do is an independent check that a system's design suits what it has to do, and that the build keeps to that design. We review designs before build and systems in production, including against the Azure Well-Architected Framework. We also act as design authority and review AI agent architectures. Reviews are fixed price, quoted after a short scoping call.

Why architecture needs assuring when AI writes the code

Most architecture problems we are asked to look at were not visible in the first design. They build up one change at a time, as each change takes the direct path through the layers because the direct path still passes the task. Coding agents take that path for the same reason people do, and they make many more changes in a day.

In our experience, written guidance on its own does not stop this. A design document improves the first draft but cannot guarantee the result. Architecture holds when it is checked by someone who did not design it, and enforced by checks that fail the build when a change breaks it.

We have carried out architecture reviews and design authority work for clients before, and we build our own software under the same guardrails we recommend. The example below follows one AI-written change through those guardrails.

An example of architecture guardrails on one AI-written change: an architecture test catches a layer breach seconds after the edit, the agent fixes it, and an engineer signs off. Illustrative data for a fictional system.

Four kinds of architecture assurance

Each answers a different question, and most clients start with a review.

Review a proposed design

An independent review of a solution architecture before the build starts, whether your own team or another supplier drew it up. We check it against your requirements, the expected load and your security and data constraints, so changes are made while they are still cheap.

Review a live system

An architecture review of a system already in production. For systems on Azure, we review against the five pillars of the Microsoft Azure Well-Architected Framework: reliability, security, cost optimisation, operational excellence, and performance efficiency.

Ongoing design authority

We act as the independent technical design authority on a programme someone else is delivering, reviewing significant design decisions as they are made rather than after the code is written.

AI agent and LLM architecture

A review of systems built on large language models (LLMs) and AI agents: which tools an agent can call, where data boundaries sit, how outputs are evaluated, and which guardrails stop it acting outside its remit.

How we keep the build to the agreed architecture

A review tells you whether the design is sound today. When the system is built with AI coding tools, we also make the agreed architecture something the tools have to follow:

  • Rule files and Claude skills state the layers, boundaries and house patterns, and the agent reads them before it writes code.
  • Architecture tests, such as ArchUnitNET for .NET and dependency-cruiser for React, fail the build when a change crosses a forbidden boundary.
  • Hooks run those checks after every edit, so the agent fixes its own violations while the change is still in context.
  • Concerns that need judgement, such as pattern infringements and database schema changes, go to an AI review that flags them and a senior engineer who decides.

This is how we build our own software. Our report Inside the Harness describes it in full, including its limits.

How an agreed architecture is enforced on AI-written code, from design review to rules, build checks and engineer sign-off
Five layers that keep AI-written code to an agreed architecture. First, the agreed design, reviewed independently: layers and boundaries, integration patterns, and security and data limits. Second, guidance read before code is written: rule files for layers and house patterns, and Claude skills for repeated changes. Third, highlighted, enforcement that fails the build: ArchUnitNET layer tests for .NET, dependency-cruiser boundaries for React, banned APIs enforced by analysers, and hooks that run the checks after every edit. Fourth, judgement, where AI flags and people decide: an AI pattern review and senior engineer sign-off. Fifth, oversight by a design authority: significant decisions reviewed, and rules updated as the design changes.

How an architecture review runs

30 minutes

Scoping call

We agree what you need assured and why: a design before build, a live system, a programme that needs a design authority, or an AI agent. We then quote a fixed price for a review, or a price for ongoing design authority work.

Review

Senior engineers read the design documents, the code and the infrastructure configuration and, where we can, talk to the people who made the decisions. The depth depends on the scope agreed on the call.

Report and walkthrough

You receive a written report with findings rated by risk, each with a recommendation. We walk your team, or your supplier, through it and answer questions.

Hold the line

Where the system is built with AI coding tools, we can turn the agreed architecture into Claude skills, rule files and automated checks, so it is enforced on every change. Where a programme needs one, we stay on as design authority.

Seen enough? Let's talk through your requirements.

Book a free consultation

Frequently asked questions

What is architecture assurance?

Architecture assurance is independent checking that a system's design suits what it has to do, and that the system being built still follows that design. It covers reviews of a proposed design, reviews of a live system, design authority on a programme, and reviews of AI agent architectures. Where the code is written with AI tools, it also covers the guardrails that keep each change inside the agreed architecture.

Can you review a design another supplier has proposed?

Yes. We review designs drawn up by your own team and by other suppliers, before the build starts or part of the way through it. The report sets out each finding, the risk it carries and what we recommend, so you can take it back to the supplier.

Do you review against the Azure Well-Architected Framework?

Yes, for systems hosted on Azure. We use the five pillars of the Microsoft Azure Well-Architected Framework (reliability, security, cost optimisation, operational excellence, and performance efficiency) to structure a review of a live system. We are a Microsoft Solutions Partner with designations in Digital and App Innovation (Azure) and Infrastructure (Azure), plus the DevOps with GitHub on Azure specialisation.

How do you stop AI coding tools drifting from the architecture?

We state the architecture in rule files and Claude skills that the coding agent reads before it writes code, so the first draft is usually right. Architecture tests such as ArchUnitNET for .NET and dependency-cruiser for React then fail the build when a change crosses a forbidden boundary. Hooks run those checks after every edit, so the agent fixes its own violations before a reviewer sees them. Our post on stopping AI generating tightly coupled code shows the rules in full.

Can you act as design authority on a programme another supplier is delivering?

Yes. As design authority we review significant design decisions as they are made, and we tell you plainly where we disagree with the supplier and why.

Do you review AI agent architectures?

Yes. For agents and other LLM-based systems we review which tools and data the agent can reach, how its permissions are limited, how its outputs are evaluated, and which guardrails stop it acting outside its remit. Our guide to deploying Claude-powered agents on Azure covers the patterns we review against.

What does architecture assurance cost?

Reviews are fixed price, quoted after a short scoping call, because the cost depends on the size of the system and the depth of review you need. Ongoing design authority work is also quoted after that call. Book a consultation to get a quote.

See how AI is changing how we build software

Our quarterly AI Velocity Report tracks real delivery metrics from live projects: how much of our code is AI-authored, how delivery timelines compare to baseline, and which tools are making a measurable difference. No marketing spin, just honest data from a team that builds software every day.

Read the latest AI Velocity Report

Get an independent view of your architecture

Book a consultation and we will tell you which kind of review fits, what it covers, and what it will cost.

Book a consultation

or call 01202 006729