DEV Community: Rlabs

Two Pillars Protocol — A maturity model for AI-era software engineering

Rlabs — Mon, 08 Jun 2026 23:17:51 +0000

Software engineering has had maturity models for forty years. CMMI told organizations whether their processes were repeatable. ISO/IEC 33000 told them whether quality was measurable. Pöppelbuß & Röglinger (2011) gave the field a methodology to evaluate the maturity models themselves.

None of them speak the language of the engineer who, last Tuesday, dispatched four agentic flows in parallel, gated three of them with tests, killed one because the spec was wrong, and shipped the surviving merge inside two hours.

That engineer is doing something old (engineering) and something new (engineering with AI as a collaborator). The new part isn't "uses AI tools" — that's like measuring a programmer in 1995 by whether they used an IDE. The new part is how the work is structured when an engineer can hold multiple evaluation axes active in parallel — architecture, product, code, validation — and integrate what survives.

The Two Pillars Protocol is an instrument and a maturity model for measuring exactly that: the new individual cognitive capacity, and the organizational conditions that let it consolidate.

The two pillars

Pillar 1 — Mixer Mode (individual). The cognitive disposition to keep multiple evaluation axes active in parallel without switching hats. Not multitasking — modulation. Three sub-dimensions: Multiplicity, Simultaneity, Integration. Server-side scored from 18 items with explicit weights and inverse penalties.

Pillar 2 — Meta-Software (organizational). Software (and the organization around it) that understands, modifies, validates and supports other software at the symbolic level. Four D-scores: D1 Cognitive, D2 Meta-Software, D3 Institutional, D4 Exposure.

The two pillars compose into a 2D quadrant: Leading edge / Orchestrator without theory / Theory without practice / Early in the curve.

What the instrument is

78 items across 6 blocks (67 scored + 11 metadata/consent). 12–18 minutes.
Server-side scoring (we never trust client-computed scores).
K-anonymity ≥ 3 per aggregate cell. No org or sub-team reported with fewer than 3 respondents.
Token-based individual reports — no account, no email login required.
Cycle mode for organizations — internal cohort, aggregate dashboard, individual reports.
Pilot license open by design. Operationalization and scoring code public at v0.5.

Why we're publishing it now

The instrument is in pilot v0.4. We've validated content with a handful of friendly engineers; we have early data from a small private cohort. The instrument works end-to-end.

What we don't yet know:

Reliability (Cronbach's α) — needs ~200 respondents per functional area
Predictive validity — needs 12–24 months longitudinal
Cultural transferability — designed in EN, untested in translation
Latent construct validity — factor analysis pending

These are open empirical questions. We're publishing now to gather the data needed to answer them.

How to participate

Take the diagnostic yourself. ~15 minutes. Individual mode is free, no account needed. The output is a private report with the Mixer Index, D-score perceptions of your org, quadrant placement, and peer comparison context. The private URL is the credential — bookmark it to re-access.

→ https://assess.rlabs.cl/v1/

Run a cycle in your organization. For tech leaders who want to assess their team systematically. Self-service from the same URL with the ?cycle=new flag.

Engage with the model. If you find a measurement issue, missed prior framework, or operationalization issue, we want to know. contacto@rlabs.cl.## Where this is going

The Two Pillars Protocol is in pilot v0.4. The v0.5 sprint completes cycle-aware reporting and the public release of the operationalization and scoring code. The v1 paper writes up the methodology, the crosswalk vs prior models (CMMI, ISO/IEC 33000, P&R 2011), and the initial empirical findings as the data accumulates.

The platform is operational. The model is real. The limitations are real and named.

Full conceptual depth and crosswalk methodology: https://rlabs.cl/blog/two-pillars-maturity-model-proposal

Two Pillars Protocol · pilot v0.4 · contact contacto@rlabs.cl

Stop prompting "write me an API" — teach the LLM the shape first

Rlabs — Sun, 19 Apr 2026 23:17:08 +0000

TL;DR

One-shot LLM code generation fails because it has no structural context.
Archetypes are a YAML contract that fixes that. I'll walk through one
end-to-end.

The "90% right, 10% wrong in load-bearing places" problem

[2-3 párrafos con ejemplos reales: layer leakage, mocked tests,
error paths que pierden contexto en el stack trace]

What a structural archetype is

An archetype is a declarative contract describing:

Top-level directory layout
Component boundaries (and what crosses them)
Contracts between components
Validation gates that must pass post-generation
A self-challenge spec the agent runs against its own output

[Snippet real de un archetype: hexagonal-api.yaml, ~20 líneas]

Walkthrough: `hexagonal-api`

1. The agent reads the archetype

[Código: claude-code con MCP server configurado, invocando el archetype]

2. Generation pass

[Output esperado: árbol de archivos generado]

3. Self-challenge

The agent re-reads the archetype and scores its own output against
the contract. When it drifts (e.g., puts persistence concerns in the
domain layer) it fails the gate and iterates.

[Ejemplo: el self-challenge detecta una violación y la corrige]

4. Running the tests

[pytest output, green]

When this doesn't fit

Be honest about limits:

Greenfield > existing codebases (for now)
The archetype has to match your stack shape, not just language
Contracts that change frequently drift from the archetype — treat the archetype as the "starting chassis", not the spec of record

Other archetypes in the catalog

Short list of 5-6 with one-line use cases. Link to marketplace.

Building your own archetype

Quick pointer: the schema is documented at /docs/archetype-schema.
Anyone can publish one — sellers set their own price and can offer
seller-funded cashback.

Why I charge for this

[Párrafo honesto: pago infra, estoy invertido, precio bajo deliberado]

Author note: I'm running launch-week cashback on the 61 archetypes
I authored — code SURPRISE_DEVTO returns ~50% of the price as wallet
credit. It's funded from my royalty (not the platform's), 250 uses,
expires June 18. Feedback about which archetypes are missing is the
real currency I'm after.

Why AI-Generated Code Needs Architecture Standards (and How We Solved It)

Rlabs — Sun, 12 Apr 2026 16:05:54 +0000

Ask Claude, GPT, or Cursor to generate a REST API. You get a project. Ask again — you get a completely different structure. Different folders, different patterns, different conventions. Do it five times, maintain all five. Good luck.

This is the reality of AI-assisted development in 2026: the code works, but there's no consistency. Every generated project is a snowflake. And when your team has to maintain ten snowflakes, the speed advantage of AI disappears fast.

We built AgentGuard to fix this.

What AgentGuard Actually Does

AgentGuard is an open-source Python library that sits between your AI agent and the code it generates. It acts as an architecture layer — enforcing consistent patterns, folder structures, and conventions through what we call archetypes.

An archetype is essentially an architecture template: it defines how a project should be structured, what patterns to follow, and what conventions to respect. Think of it as a blueprint that your AI agent must follow when generating code.

The key difference from scaffolding tools like Cookiecutter: AgentGuard doesn't just create files. It works through your AI agent via MCP (Model Context Protocol), guiding the generation process step by step — skeleton first, then implementation, then validation.

pip install rlabs-agentguard

No API keys required. MIT license.

The Problem in Practice

Here's a real scenario we recorded for our demo series. We have a Note Manager API — a Flask app crammed into a single app.py file. 280 lines. Everything mixed together:

Routes, business logic, and database access in one file
Raw SQL embedded inside route handlers
Authentication with MD5 (yes, really)
Global variables for sessions and cache
No types, no tests, hardcoded secrets

It works. It runs. It's also unmaintainable, untestable, and a security risk.

This is what AI generates when you just say "build me an API" without architectural guidance. And it's what most teams end up with when they adopt AI coding tools without a strategy.

How AgentGuard Fixes It

AgentGuard operates in phases. When your AI agent receives a prompt like "generate a Note Manager API," AgentGuard intercepts through MCP and runs the generation through a structured pipeline:

1. Skeleton — Defines the complete project structure before writing a single line of code. Folders, files, responsibilities, layer boundaries.

2. Implementation — The agent generates code file by file, following the patterns defined in the archetype. Hexagonal architecture means domain logic is separated from infrastructure. Repository pattern means database access has a clean interface.

3. Validation — AgentGuard checks that the generated code actually follows the archetype's rules. Wrong layer dependency? Missing interface? It catches it.

The result: instead of a 280-line spaghetti file, you get a clean hexagonal API with separated layers, proper auth, typed models, and tests. Same functionality, completely different maintainability.

The Marketplace

The AgentGuard Marketplace currently hosts 61+ archetypes covering common patterns:

API backends — hexagonal architecture with FastAPI/Flask
CQRS services — command/query separation with event sourcing
React SPAs — component structure with state management patterns
Documentation templates — ADRs, PRDs, dev guides
Microservice scaffolds — with proper boundaries and contracts

Any team can create and publish their own archetypes. Your company's architecture standards, packaged as reusable templates that any AI agent can consume.

MCP: Why It Matters

AgentGuard uses MCP (Model Context Protocol) as its integration layer. This means it works with any AI agent that supports MCP — Claude, Cline, Cursor, Windsurf, and more.

Your IDE agent connects to the marketplace, searches for archetypes, downloads them, and applies them — all automatically. No copy-pasting configuration files. No manual setup per project.

# In your AI agent (Claude, Cline, etc.):
"Using AgentGuard with the api_backend archetype, 
 generate a Note Manager REST API with FastAPI, 
 SQLite, JWT auth, and hexagonal architecture"

The agent handles the rest.

See It in Action

We recorded a demo series showing every step, from installation to migrating real spaghetti code:

Episode	What it covers	Link
Explainer (EN)	What is AgentGuard? — 4 min overview	Watch
Explainer (ES)	¿Qué es AgentGuard? — explicación en español	Watch
Ep.01	Installation & Setup — pip install to running in 4 min	Watch
Ep.02	Project from Scratch — empty folder to working API	Watch
Ep.03	Auto Documentation — ADR, PRD, Dev Guide generated	Watch
Ep.04	Spaghetti → CQRS — 280 lines of chaos to clean architecture	Watch

The migration demo (Ep.04) is the most compelling: same app, same functionality, before and after. The spaghetti app runs, we migrate it live with AgentGuard, and the result runs with the same API contract but clean architecture underneath.

The Stack

For the demos we used:

LLM: Qwen 3.5 (running locally via Ollama — no cloud dependency)
Agent: Cline in VSCode
QA layer: AgentGuard MCP server
Environment: Clean Windows Sandbox

This is intentional. We wanted to show that AgentGuard works with local models, not just cloud APIs. If a local 7B model can follow architectural patterns through AgentGuard, any model can.

Who Is This For?

Tech leads and architects who want their team's AI-generated code to follow company standards. Instead of writing a 50-page architecture guide that nobody reads, package your standards as an archetype. The AI follows it automatically.

Solo developers who want consistency across their own projects. Same patterns, same structure, every time. Six months from now, you'll actually understand the code your AI generated today.

Teams adopting AI coding tools who are discovering that "fast code" and "maintainable code" are not the same thing. AgentGuard bridges that gap.

Get Started

pip install rlabs-agentguard

GitHub: github.com/rlabs-cl/agentguard-lib
Marketplace: agentguard.rlabs.cl/marketplace
PyPI: pypi.org/project/rlabs-agentguard

MIT license. No API keys. One pip install. We'd love feedback — drop an issue on GitHub or leave a comment here.

Why AI-Generated Code Needs a Quality Layer

Rlabs — Wed, 08 Apr 2026 18:30:52 +0000

Why AI-Generated Code Needs a Quality Layer

When we started RLabs, we believed in a simple promise: let AI agents write code faster. But we quickly discovered a harder truth—speed without structure creates disasters.

I've watched Claude and GPT produce dozens of lines of plausible-looking code that falls apart the moment you try to run it. Hallucinated imports. Inconsistent architecture. Missing error handling. Functions that assume globals exist. Async/await patterns that deadlock. It's not the models' fault. They're trained to continue patterns, not to architect systems.

The first instinct was predictable: "Let's just prompt harder." Ask the agent to use a specific pattern. Add examples to the context. Tell it to validate its own output. Some of this helps, but it doesn't scale. Every project needs slightly different rules. Every team has different conventions. And most critically—checking your own work is not the same as building with constraint.

We built AgentGuard to solve this.

The Problem Isn't the Agent. It's the Contract.

When developers write code without structure, we catch mistakes in code review. When agents write code, we don't have that. So we decided: lock down the structure before the agent even starts typing.

AgentGuard is an MCP (Model Context Protocol) server that guides AI agents through a five-step refinement process:

Skeleton — Agent creates the file structure and function signatures without implementation. Catches architectural mistakes early.
Contracts and Wiring — Agent specifies types, dependencies, and interfaces. You verify they match your system before any logic exists.
Logic — Only now does the agent implement the actual code. But it's constrained by the contracts above—no surprise dependencies, no weird globals, no architectural detours.
Challenge Criteria — Agent generates self-review criteria against quality standards. Built-in validation before a single test runs.
Validate — Final check: syntax, lint, types, imports. Does the structure match the contract?

All of this runs locally, without calling an LLM server. AgentGuard doesn't generate code. It structures the work.

Archetypes: Reusable Quality Patterns

Not every team needs the same structure. A hexagonal architecture API looks completely different from an ADR documentation system, which looks different from a Go-to-Market campaign builder.

We created archetypes (architectural templates) for this. An archetype is a set of templates + prompts that define how each of the five steps should work for your specific context.

We ship 61+ archetypes on our marketplace at agentguard.rlabs.cl/marketplace. Hexagonal API. ADR. Event-driven systems. FastAPI backend. CQRS patterns. Each one encodes architectural knowledge into a repeatable pattern your agent can follow consistently.

When you run AgentGuard with an archetype, the agent doesn't see generic instructions. It sees the exact structure your team cares about. The validation it runs matches your conventions.

Real Numbers, Honest State

We've been live for a few months:

878+ downloads/month on PyPI
9 stars on GitHub (we're not a viral hit, and we're okay with that)
Used by teams running production workloads on the five-step system
In active development — improvements to the refinement process every sprint

This isn't a wrapper around ChatGPT. AgentGuard doesn't touch your API keys or call external models. It runs locally. It works with Claude, GPT, Cline, or any agent that speaks MCP.

The Next Step

If you've felt friction between "AI-generated code" and "production-ready code," AgentGuard was built for that gap.

pip install rlabs-agentguard

No API keys. No setup ceremony. Then explore archetypes for your use case at agentguard.rlabs.cl/marketplace.

We built this because we got tired of code that looked right until it didn't. Structure matters more than speed.

DEV Community: Rlabs

Two Pillars Protocol — A maturity model for AI-era software engineering

The two pillars

What the instrument is

Why we're publishing it now

How to participate

Stop prompting "write me an API" — teach the LLM the shape first

TL;DR

The "90% right, 10% wrong in load-bearing places" problem

What a structural archetype is

Walkthrough: hexagonal-api

1. The agent reads the archetype

2. Generation pass

3. Self-challenge

4. Running the tests

When this doesn't fit

Other archetypes in the catalog

Building your own archetype

Why I charge for this

Why AI-Generated Code Needs Architecture Standards (and How We Solved It)

What AgentGuard Actually Does

The Problem in Practice

How AgentGuard Fixes It

The Marketplace

MCP: Why It Matters

See It in Action

The Stack

Who Is This For?

Get Started

Why AI-Generated Code Needs a Quality Layer

Why AI-Generated Code Needs a Quality Layer

The Problem Isn't the Agent. It's the Contract.

Archetypes: Reusable Quality Patterns

Real Numbers, Honest State

The Next Step

Walkthrough: `hexagonal-api`