Building Fabrica: an OpenClaw plugin for structured software engineering workflows

Mateus Scheuer Macedo — Thu, 09 Apr 2026 10:59:12 +0000

I’ve been spending some time exploring a problem that keeps showing up around AI coding agents:

the models keep improving, but the engineering workflow around them is still often fragile.

A lot of current setups are good at generating momentum, but much weaker at handling the operational side of software work:

project setup
task breakdown
role separation
review flow
testing flow
stuck-run recovery
observability
onboarding for real users

That is the gap I wanted to explore with Fabrica.

MestreY0d4-Uninter / fabrica

Autonomous software engineering pipeline for OpenClaw

Fabrica

Autonomous software engineering pipeline for OpenClaw.

Fabrica turns a natural-language project description into a fully executed engineering workflow: intake, specification, issue decomposition, development, code review, testing, and merge. It orchestrates AI agents as specialized workers (developers, reviewers, testers) through a deterministic finite state machine, with repair-oriented recovery when runtime signals or stack environments are incomplete.

How it works

  Human idea (text)
        |
        v
  [ Intake & Spec ]  ←  classify → interview → generate-spec
        |
        v
  [ Issue decomposition ]  ←  GitHub issues created
        |
        v
  [ developer ]  →  opens PR
        |
        v
  [ reviewer ]   →  approves or requests changes
        |
        v
  [ tester ]     →  runs QA, posts evidence
        |
        v
  [ merge ]      →  PR merged, issue closed
        |
        v
       done

The heartbeat ticks every 60 seconds. On each tick, Fabrica alternates between a repair pass (fixes stale states, retries incomplete completion signals, and reconciles…

View on GitHub

What Fabrica is

Fabrica is an open-source plugin for OpenClaw focused on orchestrating software engineering workflows in a more structured way.

The goal is not to build “a magical agent that replaces a team”.

The goal is to experiment with a workflow layer around agents that is:

more explicit
more auditable
more predictable
more operational
easier to test and criticize

In practice, the idea is to start from an initial input coming from Telegram or CLI and move that through a fuller pipeline.

What the workflow looks like

At a high level, Fabrica is designed around steps like:

intake of the idea or project request
bootstrap of the project and repository
issue and task organization
handoff between agents with different roles
- developer
- reviewer
- tester
GitHub PR flow
validations when the run starts drifting
recovery paths when the process gets stuck or loops
doctor, metrics, and operational visibility

So the value is less about “AI writing code by itself” and more about organizing the software workflow around it.

Why I built it

What kept bothering me in many agent demos was not the generation quality itself.

It was everything around it.

A lot of workflows still feel like this:

context gets scattered
responsibilities are blurred
retries happen without much discipline
failures are hard to diagnose
loops are easy to trigger
setup looks easier than it really is
onboarding often breaks for new users

That makes many agent workflows look impressive at first, but unreliable in repeated use.

I wanted to see what happens if the focus shifts from “make the agent do more” to “make the workflow easier to understand and operate”.

Current state

Fabrica is still early.

I do not want to present it as finished or polished.

But it is already functional, and a lot of recent work has gone into making it less like a demo and more like something people can actually stress:

stronger setup and onboarding
better post-PR convergence
QA evidence validation
doctor and metrics
clean-machine validation
fixes based on real onboarding friction

So the current phase is not “look at my idea”.

It is more:

this already works, now I need real usage, real criticism, and real feedback.

What I want feedback on

If you take a look, the feedback I’d value most is around:

architecture
workflow design
UX
onboarding
failure handling
observability
where human intervention should happen
where the system is too complex for the value it provides

I’m also very interested in hearing whether this feels genuinely useful or whether it still looks like too much machinery around a problem that should stay simpler.

That distinction matters.

What I’m explicitly not trying to claim

I’m deliberately avoiding framing this as:

“AI replaces engineering teams”
“fully autonomous software factory”
“push button, get product”
“perfect automation”

I think that framing creates the wrong expectations and attracts the wrong discussion.

The more honest description is:

an experimental but functional open-source plugin that tries to make agent-driven software workflows more structured and operational.

Repo

Repository:

github.com/MestreY0d4-Uninter/fabrica

If you want to try it, criticize it, break it, or tell me where the design is overengineered, that would be genuinely useful.

DEV Community: Mateus Scheuer Macedo