It's undeniable that AI has changed the technology landscape, but everything I read is deeply focused on the impact to Engineering, while Architects rarely get the same attention. In this article, I wanted to highlight a Solution Design I recently worked through, the Agentic AI tooling used, and what the final product looked like. This is going to be raw and honest because it was my first time using this approach.

Context;

I work as a Solutions Architect for a FinTech startup company. Although the primary focus is Payments, a significant part of the business is centred around Loyalty solutions. Working for a startup means new projects can arrive quickly, and workloads have to pivot rapidly to satisfy client demands — because clients pay the bills.

The Requirement;

Anybody familiar with the Italian Prize Issuance Regulation D.P.R 430/2001?

No? Me neither.

The ask from the business was to create an Instant Win game where, when a customer completes X transactions within a 24-hour period, they receive a game token. That token is then used in a random game of chance where a prize may be awarded.

Random prize issuance in Italy is heavily regulated, and the regulation has to be followed precisely.

I am also not an Italian speaker, but the Statement of Work and all third-party integration documents were written in Italian. There were a lot of integrations too — this solution sat in the middle of a large ecosystem involving external API integrations, file exchange, and a bespoke vendor-implemented SSO solution.

Then came the third and final caveat: the timelines for completing the design were measured in days, not weeks, due to a committed client delivery date.

It wasn't exactly a winning position, but we don't shy away from a challenge.

Tooling;

The Engineering team I work with all have access to Agentic AI coding tools, with Warp being the frontrunner in terms of adoption. At times, I've even pulled stories directly from the board and implemented changes myself using the tooling, so I was already familiar with the approach.

My immediate thought was:

Why can Engineers vibe with AI, but Architects can't?

Agentic Solution Design

It would have taken weeks to fully understand the regulation and translate all the supporting documents, which simply wasn't an option.

Instead, the only viable approach was to "Vibe Architect" the solution and leverage Warp to do the heavy lifting while I guided it through the process.

The setup looked something like this:

The initial workflow;

• Pull all business documents into a local repository so Warp could consume the full context — still in their native Italian.
• Pull down incumbent codebases to use as reference models for coding standards and implementation approaches.
• Pull down the microservices specification catalogue to use as reference models for best practices.

Then came a pause.

I spent a couple of hours in Miro scoping out a high-level diagram of the landscape: what already existed, what needed to be modified, and what needed to be created. The classic Architect "boxes and arrows" exercise.

That step was critical because it gave the AI bounded contexts and a defined scope to work within.

The final steps were:

• Point Warp at the Miro MCP and the board itself for context.
• Point Warp at the Jira MCP and key Architectural constraint artefacts.

Then we wrote the instructional prompt and off we went.

The Output

I kept tight control over the AI throughout the process. After every major step, it would pause and wait for feedback, allowing me to continuously steer it in the right direction.

Together, we produced a large number of markdown documents — all in English — covering:

• Algorithm Design: how prizes are awarded fairly and randomly
• High-Level Architecture
• Service Designs for each new service
• Service Modifications for each updated service
• Requirement generation, including NFRs
• SSO implementation
• Observability, error handling, and alerting strategy
• Testing strategy

Normally, I like to construct my Confluence Solution Design documents manually, taking generated markdown and curating it carefully for the Engineering teams.

Given the time constraints, however, I asked Warp to write everything into Confluence for me.

Any diagrams were generated as Mermaid code, which meant I could quickly convert them into images and embed them into Confluence myself.

I also found myself treating Warp almost like a Technical Architect throughout the process. Due to Regulation D.P.R 430/2001, there are strict software controls that must be implemented. The Solution Design therefore had to go much deeper technically than our Engineering teams would normally expect from Architecture documentation.

The term Chi-Squared Distribution will now haunt me for the rest of my career.

The final step was asking the AI how confident it was that the proposed solution was compliant and would pass auditing.

It was happy, so I was happy.

The completed Solution Design was then handed over to Delivery Managers to convert into Epics and Stories — again using Agentic AI, this time directly through ChatGPT.

Implementation

As previously mentioned, the Engineering teams already use Agentic AI coding tools extensively. They were pulling stories and epics directly from Jira and, because the Technical Design had already broken work down into granular detail, Engineers were able to start quickly and work largely in parallel — effectively one Engineer per service.

Most of the collaboration concerns had already been solved during the design phase, allowing teams to work independently and integrate everything later.

Up front, we knew that investing a couple of days embedding the design and business domain into the team would allow them to better support their AI agents. That meant each Engineer became deeply knowledgeable within their service domain.

This paid dividends because it freed me up to move directly onto the next Solution Design.

The Spanner in the Works

Regulation D.P.R 430/2001 requires a signed compliance document from the Technology team evidencing adherence to the rules.

Although I had designed the solution, implementations naturally evolve during delivery.

By pulling all the codebases down locally and asking Warp to perform a full end-to-end audit of the implementation against the Confluence documentation, I was able to validate the final state of the solution.

Warp then had enough context to generate the compliance documentation for me as well, including relevant reference code examples where required.

We were more than compliant and proved it.

In Conclusion

Was I comfortable "Vibe Architecting" this?

Nope.

I think most Architects are control freaks at heart and want to be involved in every detail.

Was I confident?

Also nope.

I didn't hold enough of the implementation detail in my head, and I'm used to understanding everything end to end.

Did it work?

Surprisingly, yes.

By some miracle, all the AI involved across the delivery managed to hit the brief, fulfil the requirements, and remain compliant with the regulation.

What does this mean for me moving forward?

I honestly don't know.

What I do know is that I'm now working constantly alongside Warp, taking requirement documents and vibing solutions at a pace I couldn't previously achieve. I'm finding its insights especially valuable when producing change requests against incumbent codebases, where I can now generate detailed technical specifications and estimates far more quickly.

Does it sometimes mean I make the code changes myself?

Absolutely.

It's fun — and sometimes the documentation takes longer than the actual implementation.

What it also means is that I can significantly increase my output. I have 14 Engineers that I need to continuously feed work into, and the tooling helps me maintain consistency and quality across everything I produce.

I'm still trying to find the sweet spot between Solution Architecture and Technical Architecture when it comes to documentation depth. The AI can absolutely generate line-by-line code change specifications, but at some point that starts to diminish the value Engineers bring — because Engineers consistently provide insight and nuance during implementation that would otherwise be lost.

I'm finding myself experimenting more and more with AI tooling, and I'm convinced that over time the vast majority of what I do will become increasingly automated. I'll code with Warp, I'll research with Gemini, I'll use ChatGPT for quick code formatting or text analysis, then I'll use Gamma to make my presentations look pretty and professional. As for Miro, that's a post for another time.....

Much like modern Engineering workflows, I suspect my role will evolve into reviewing outputs, refining prompts, steering agents, and validating outcomes — perhaps even letting AI generate the diagrams for me too.

Hopefully one day I won't still be fixing Mermaid diagrams manually.

Until then, I still provide value.

(Yes, this post was proof read by AI but my voice is still in it!)