Structor Agenticus Systematum

Software is changing - not because we learned a new language, but because the unit of value is shifting.

In all truth, it was never about the code. Code is a medium. Outcomes are the product. Agile, lean, product management - all are focusing on outcomes. For decades. Technical excellence is of very high importance, but it’s production value dropped.

We’ve got another boost in engineering efficiency through ability to iterate quicker over the code using LLM-based “thinking” agents. They are really brilliant. In many cases.

In the new era, engineering organisations must optimise for verified outcomes inside messy real environments - with humans and agents co-producing systems.

This is where the archetype - Structor Agenticus Systematum - emerges.

Structor Agenticus Systematum (Agentic System Builder) is a practitioner who constructs systems where:

• humans and AI agents collaborate,

• intent and constraints are explicit artifacts,

• verification is continuous,

• and accountability is measured in outcomes, not outputs.

Not “prompt engineering”. Not “faster coding”.

This correlates very well with the ideas of forward deployed engineers, augmented software development, conversational programming and, of course, vibe coding (in a good sense).

To decompose it even further. On the first iteration:

1. Intent is captured through meetings (human-to-human).

2. Meetings are recorded and transcribed into text (voice-to-text models).

3. Text is analysed and decomposed into specifications and tasks (humans + LLMs).

4. Tasks are converted to code (humans + coding agents).

5. Tests are written to verify functional intent (humans + coding agents).

6. Target infrastructure is configured to run the code (humans + coding agents).

7. Pipelines and additional guard rails (security, structure, quality) are coded and used to deliver code (humans + coding agents).

On subsequent iterations, intent changes are captured in the same way, specifications and guard rails are extended, internal context is growing.

At some point, certain change types can be delivered without human-in-the-loop. Not because humans are not needed anymore, but because our delivery mechanisms are automated-enough, our accumulated context is rich-enough for the models to interpret it correctly, our guard rails are proven-enough to catch anomalies and issues.

It requires an engineering mindset and effort to actually work.

Structor Agenticus Systematum, FTW!