The problem

Most AI architecture discussions stall at the same wall: autonomy vs. safety, quality vs. latency, personalization vs. privacy, context depth vs. cost. Teams either pick a side and eat the downside, or they throw more prompt engineering at the symptom instead of the tension itself. There’s no shared vocabulary for saying “these two requirements are actually in conflict, and here’s how engineering has solved that class of conflict before.”

That’s not just a personal frustration — it’s a recurring failure mode on any team shipping agentic systems. Architecture reviews turn into opinion contests because nobody has a repeatable way to name the contradiction, let alone a library of proven resolution patterns to draw from. TRIZ, the Soviet-era systematic-innovation methodology, was built to solve exactly this in mechanical and process engineering: it catalogs 40 inventive principles derived from patterns across hundreds of thousands of patents. I wanted to know if that same discipline transfers to agentic AI design.

The approach

I built this as a structured study, not a piece of software: a working folder of source material (agentic AI pattern encyclopedias, an extended agentic AI textbook, success-framework references) plus a TRIZ subfolder that turns the theory into a usable process. The core deliverable is a 7-step workflow that takes a fuzzy AI design problem all the way to a tested prototype plan: (1) frame the problem — context, scope, inputs/outputs, constraints, design space options; (2) decompose it into components with defined interfaces and risk points; (3) convert the friction points into explicit contradictions — an “improve” parameter and a “worsen” parameter, each with a metric; (4) map those contradictions to TRIZ inventive principles adapted for agentic systems (segmentation, prior action, intermediary, dynamization, local quality, and others); (5) turn the selected principles into an actual architecture — agents, prompt contracts, JSON action schemas, control points and thresholds; (6) brainstorm and score multiple distinct concepts rather than variants of one idea; (7) define the evaluation harness — golden dataset, release metrics, monitoring and rollback rules.

Each step is captured as a reusable prompt template (persona, goal, objectives, input, output) that a learner or practitioner can copy, fill in the brackets, and run against their own problem — this is prompt engineering used deliberately as the “workbench” at every stage of a design process, not as a one-off trick. I worked the whole process end to end against two concrete problems to prove it out: an AI multi-agent email-triage-and-draft-reply system (with the full agent breakdown — Triage Agent, Draft Agent, Verifier/Policy Agent, human approval gate — and the resulting contradiction-to-principle mapping, e.g. autonomy-vs-safety resolved via segmentation of draft from send, a policy-gate intermediary, and human-in-the-loop feedback), and a RAG system design. There’s also a course outline sketched out (“TRIZ for Agentic AI training kit”), a mapping of the 39 classical TRIZ engineering parameters to the ones actually applicable to software/AI design, and a worked example set showing each TRIZ principle applied to a concrete AI scenario.

What I learned

The transfer works better than I expected, but only once you stop treating TRIZ’s 40 principles literally and instead translate them into agentic-system moves — segmentation becomes “separate the drafting agent from the sending agent,” intermediary becomes “insert a policy-gate agent between generation and action,” prior action becomes “pre-checks and dry-runs before the risky step.” The real value isn’t the principle list itself, it’s the discipline of step 3: forcing yourself to write the contradiction down as two measurable, opposing parameters before jumping to a solution. Most architecture debates skip that step entirely and argue past each other because nobody agreed on what’s actually being traded off.

Where this could go

The natural next step is turning the prompt templates into an actual reusable tool — a CLI or lightweight app that walks a team through the 7 steps interactively and stores the contradiction log and principle mappings per project, instead of copy-pasting templates by hand. At team scale, that contradiction log is the real asset: an architecture review board could keep a running library of “contradictions we’ve resolved before and how,” the same way TRIZ’s original 40 principles were mined from a huge corpus of patents. Any org building multiple agentic systems is re-deriving the same autonomy-vs-safety and quality-vs-cost trade-offs project after project; a shared, TRIZ-structured decision log would let new teams start from precedent instead of from scratch. It’s also a natural fit for a training curriculum — the course-outline draft in this study is a first pass at that.