AI architecture reviews need change control, not more advice
AWS has made its Well-Architected review an agent. That sounds like one of those announcements you skim between a new instance family and a pricing page, but I think it is more consequential than it first appears.
The old model was familiar: schedule a workshop, answer a large questionnaire, collect a list of improvements, and argue about them in a backlog grooming session six months later. The new AWS Well-Architected Agent continuously inspects an environment, prioritises recommendations against stated business goals, and can return ready-to-deploy remediation guidance. For infrastructure-as-code reviews, it can return an updated template with fixes applied.
That last sentence changes the category of problem.
Advice is cheap. A finding in a spreadsheet can be ignored, deferred, or debated. A proposed Terraform change is much closer to a production change. It can alter resilience, cost, permissions, data paths, and failure modes. Once architecture review starts producing code-shaped output, the interesting question is no longer whether the tool is clever. It is whether the team has change control around it.
The recommendation is not the change
Let us be fair to the product: this is useful. An always-on review can surface the boring things humans miss when they are busy shipping features: a database with a fragile availability configuration, a security control that drifted, a resource that is expensive for no good reason, or an architectural trade-off that stopped being reasonable two quarters ago.
AWS says the agent works across cost, security, performance, and resilience. It is designed to rank findings around goals the team sets, show cross-pillar trade-offs, and provide automation-ready fixes. The IaC workflow is deliberately on-demand and analyses templates before deployment. That is a sensible place to use machine assistance.
But a recommendation becoming executable does not make it self-approving.
An agent can see that multi-AZ failover improves availability. It cannot know, by itself, whether the extra cost fits this quarter’s budget, whether the application is actually ready for failover, whether a migration has already been planned, or whether the proposed modification violates a contract that lives outside AWS. It can recognise a pattern. It cannot own the business and operational consequences of changing it.
The clean boundary is this:
An AI architecture recommendation is evidence and a proposal. It becomes a change only when a named owner accepts the evidence, understands the blast radius, and approves a reversible execution path.
That is not anti-AI caution. It is the normal standard we should already apply to infrastructure changes proposed by a person, a linter, a consultancy, or a production incident.
Treat the output like a pull request
The best mental model is not “our new AI architect.” It is “a prolific contributor that opens very confident pull requests.”
That contributor can be extremely valuable. It can find more things than any individual reviewer, prepare a useful diff, and explain why it believes the change helps. It can also miss local context, overweight the provider’s default patterns, and be wrong in a way that sounds authoritative.
So give its work the properties of a good pull request:
1. Attach evidence, not just a verdict
“Enable this setting” is not reviewable enough. Every recommendation should point to the concrete source that caused it: the affected resource and current state, the IaC file and relevant line, a metric trend, a policy requirement, or an incident that demonstrates the risk.
This matters for more than audit theatre. Evidence lets an engineer tell the difference between a real regression and a generic best-practice collision. It also gives the next person enough context to challenge the conclusion without reverse-engineering the agent’s reasoning.
If the tool cannot show the input and rule behind a recommendation, downgrade the output from “candidate change” to “lead worth investigating.”
2. Make ownership explicit
The person who owns the workload should own the decision, even if a platform team operates the review tool. Central teams can define policy, provide templates, and help with difficult trade-offs. They should not quietly become the business owner for every generated change.
The review record needs a named accountable owner, a decision, and a reason. “Accepted”, “rejected”, and “deferred” are all useful outcomes when they are connected to evidence. “Left unread until the dashboard turns red” is not.
For higher-risk changes, include the security and cost owners early. A fix that reduces one operational risk by creating a new data-exposure risk or a permanent spend increase is not obviously a fix.
3. Separate detection from modification
I would let an agent inspect broadly and propose freely. I would be much more conservative about letting the same identity inspect, decide, and apply.
Detection can run on a schedule with read-only permissions. Generating a patch can happen in a branch, a change set, or another reviewable staging area. Applying that patch should travel through the same deployment controls as any other infrastructure change: peer review, CI, policy checks, environment promotion, and an approval appropriate to the risk.
This separation gives us an important safety property: discovering an improvement does not also grant the power to make it real. It also limits the damage when the recommendation is wrong, stale, or based on an incomplete view of the system.
4. Ask for a blast radius and a rollback before approval
The generated diff is not the whole change. A reviewer needs to know what will be recreated, restarted, reconfigured, or made more expensive; which applications depend on it; and how to unwind the change if the production result is worse than the predicted one.
Some changes are naturally reversible. Others are migrations disguised as one-line configuration improvements. An architecture-review workflow should classify that difference instead of treating every recommendation as equally safe to deploy.
My minimum checklist for a generated remediation would be short:
- What evidence triggered this recommendation?
- Who owns the affected workload and approves the trade-off?
- What changes at runtime, and what is the plausible blast radius?
- How will we verify the intended result after deployment?
- What is the rollback or mitigation if that verification fails?
- Which security, privacy, and cost consequences need a separate sign-off?
If those questions feel heavyweight for a small correction, that is useful information too: automate the low-risk class with narrowly defined rules. Do not use the existence of easy changes as a reason to grant blanket authority for hard ones.
Learn from the recommendations you ignore
An AI review system needs a feedback loop, otherwise it becomes a very expensive source of notification fatigue.
Track recommendations that were accepted, rejected, and repeatedly deferred. Rejections should be categorised: false positive, insufficient context, accepted risk, wrong priority, not feasible yet, or provider-specific advice that does not fit the organisation. The taxonomy does not need to be perfect. It needs to reveal whether the tool is helping or merely producing a polished version of a generic checklist.
This is where teams can improve both their policy and their own use of the agent. A recurring false positive may reveal a missing organisational rule. A repeated deferral may reveal a real architectural debt that deserves a planned investment rather than another alert. An accepted recommendation that caused pain is a reason to tighten the automation boundary.
Do not interpret ignored findings as engineer laziness by default. Sometimes the finding is right and the priority is wrong. Sometimes the finding is technically correct but commercially silly. Sometimes it is just wrong. The operating model should make those distinctions visible.
Provider advice is useful, not neutral
Provider-native architecture advice has an unavoidable bias: it sees the world through the provider’s services, control plane, and incentive structure. That does not make it bad advice. It means we should read it as we would read advice from any capable vendor: technically valuable, but not a substitute for our own constraints.
The agent may recommend an AWS-native service that genuinely simplifies operations. It may also nudge a team toward tighter coupling, a larger spend, or an operational model that does not match its skills. The correct response is neither blind adoption nor performative multi-cloud purity. It is to make the trade-off explicit and keep the decision with people who carry the consequences.
AWS’s own Agentic AI Lens makes a related point more directly: agents that act in the real world need bounded autonomy, auditability, and human oversight proportional to the risk and reversibility of the action. Architecture remediation is a good example. A weekly read-only assessment can be broad. A change that alters production topology deserves a much narrower authority boundary.
The useful part is still engineering judgment
I expect tools like Well-Architected Agent to become normal. They are a natural evolution of dashboards, static analysis, and infrastructure review: more context, better prioritisation, and less manual hunting.
That is good news, provided we avoid a familiar mistake. We should not convert a credible recommendation into a production change merely because it arrived with code attached.
The agent can make architecture review faster and more continuous. It cannot make trade-offs disappear. Someone still has to decide whether this is the right change, for this workload, at this time, with this rollback plan and this cost. The teams that get value from these tools will not be the ones that trust them most. They will be the ones that give them a useful, reviewable place in a disciplined change process.
References
- AWS Well-Architected Agent preview announcement
- AWS Well-Architected Agent documentation
- AWS documentation: conducting architecture reviews
- AWS Well-Architected Agentic AI Lens
To test my projects, I use Railway. If you want $20 USD to get started, use this link.