The craft doesn’t disappear because the code writes itself.
I build the tools, practices, and teaching that let engineers and their leaders
adopt AI without surrendering architecture, testing, and judgment. This is where that work
lives.
Better prompts aren’t the fix.
Guardrails are — because they’re deterministic.
A prompt is a request. A guardrail is a constraint the machine cannot talk its way
past. While the industry doubles down on review — more eyes, more care, more diligence
— I’m betting the other way: on structure that holds whether or not anyone is paying
attention. It isn’t a new idea. It’s what XP, TDD and continuous delivery proved
decades ago, pointed at a much faster writer.
Carry engineering excellence forward into the AI era — by making craft
enforceable, measurable, and teachable while teams adopt the tools.
AI now writes most of the code, and the industry is optimizing for more of it,
faster — while the things that made software durable quietly erode: deliberate
architecture, real tests, delivery discipline, and the human judgment that tells good from
merely plausible. Not by resisting the tools, and not by asking people to review harder.
Everything in the portfolio advances one piece of that.
About
Who’s behind the work
Max Piechota — a technical leader and educator working at
the seam of software engineering and AI-assisted development. Background across architecture
(DDD), testing (TDD), and delivery (CI/CD), plus years teaching engineers to work the way the
best teams do.
I run the platform team at First Connect, where the question I get paid to answer is what
AI actually does to a delivery pipeline. Everything in this portfolio is my own — built,
taught, and published under my own name.
The portfolio
The body of work, as separate but connected products
Each advances the mission from a different angle. Five are open today; one is
still coming.
The credibility anchor
Blueprint
A platform for making the whole shape of a product legible: business blueprint, software
architecture, and roadmap in one place. Engineers adopted it on their own.
The recognized delivery signals — DORA/DX-class — out of the box, read through
the AI-adoption lens. Leaders see what AI is doing to their delivery without first standing up
a measurement program.
Deterministic architectural guardrails for AI agents: compile the architecture diagram you
draw into a dependency linter that rejects any change crossing your boundaries — in the
agent’s loop and in CI. MIT, published, and what I use in production daily.
Three hours, live and remote: build the same module twice — once with the
architecture in prose, once compiled into a check — and time the difference. You leave
with two numbers in your own handwriting, a guardrail running on your machine, and the drift
map.
A recurring series of free live sessions on agentic coding and AI-native delivery —
the findings as they land, not a finished curriculum. Talking through the work is how I think,
so this is where that happens in public.
One unbroken thread from event storming to running software: domain model, hexagonal
boundary, walking skeleton, behavioural tests — with Blueprint and Boundry where they
naturally belong. Built trunk-based and in the open. The practices wired up and running, not
a slide deck.
