DEV Community: Miguel Miranda de Mattos

From Code to Systems: Engineering Autonomous Full-Stack Applications with Agentic Principles

Miguel Miranda de Mattos — Fri, 01 May 2026 18:55:11 +0000

From Backend Generation to Full System Generation

Introduction

In the previous article, we explored agentic coding for backend generation.

This article takes the next step:

Generating a complete, validated, full-stack system (Go + React) using an autonomous agent.

This is not scaffolding.

This is:

system generation
execution
validation
self-healing
System Architecture

project_agent_coded_go_fullstack/
├── backend/
│   ├── cmd/server/main.go
│   ├── internal/domain/
│   ├── internal/application/
│   ├── internal/infrastructure/
│   ├── tests/
│   └── go.mod
│
├── frontend/
│   ├── src/
│   ├── package.json
│   └── vite.config.js
│
└── README.md

Requirements

Python 3.10+
Go 1.20+
Node.js (18+)
Ports 8000 and 5173 available

Running the Agent

python -m venv .venv
source .venv/bin/activate
pip install openai requests
python -m agent.main

Running Generated Backend

cd backend
go mod init backend
go mod tidy
go run ./cmd/server
Running Generated Frontend
cd frontend
npm install
npm run dev
Backend Unit Tests (Go)
cd backend
go test ./...

Runtime Validation

The agent validates full CRUD:

POST /notes
GET /notes
PUT /notes/{id}
DELETE /notes/{id}

Agent Loop

generate → run → test → validate → fix

Key Principles

Tests as Source of Truth
System is correct only when tests pass.
Validation Ensures Behavior
Tests alone are insufficient — runtime validation ensures usability.
System > Code
The output is a working system, not snippets.

Appendix A — Agent (Complete)

main.py

Handles orchestration.

import json
import os

from .config import WORKDIR, MAX_ATTEMPTS, MAX_STAGNATION
from .generator import generate_repo
from .executor import run_backend, stop_backend
from .tester import run_tests
from .validator import validate_api
from .installer import install_missing
from .utils import write_files


def main():
    error = None
    previous_error = None
    stagnation = 0

    os.makedirs(WORKDIR, exist_ok=True)

    for attempt in range(MAX_ATTEMPTS):
        print(f"\n--- Attempt {attempt+1} ---")

        # --------------------------------------------------
        # GENERATE
        # --------------------------------------------------
        raw = generate_repo(error)

        try:
            file_map = json.loads(raw)
        except Exception:
            error = "Invalid JSON from generator"
            continue

        # --------------------------------------------------
        # WRITE FILES
        # --------------------------------------------------
        write_files(WORKDIR, file_map)

        # --------------------------------------------------
        # RUN BACKEND
        # --------------------------------------------------
        ok, process, run_error = run_backend(WORKDIR)

        if not ok:
            print("[executor] Failed to run backend")

            if install_missing(run_error, WORKDIR):
                error = run_error
                continue

            error = run_error
            continue

        # --------------------------------------------------
        # RUN TESTS
        # --------------------------------------------------
        test_ok, test_err = run_tests(WORKDIR)

        if not test_ok:
            print("[tester] Tests failed")

            if install_missing(test_err, WORKDIR):
                error = test_err
                stop_backend(process)
                continue

        # --------------------------------------------------
        # VALIDATE API
        # --------------------------------------------------
        valid, val_err = validate_api()

        stop_backend(process)

        if not valid:
            print("[validator] API validation failed")

            if install_missing(val_err, WORKDIR):
                error = val_err
                continue

        # --------------------------------------------------
        # SUCCESS
        # --------------------------------------------------
        if test_ok and valid:
            print("SUCCESS: System validated")
            return

        # --------------------------------------------------
        # ERROR HANDLING
        # --------------------------------------------------
        current_error = test_err or val_err or run_error or "Unknown error"

        print(f"[agent] Error: {current_error}")

        if current_error == previous_error:
            stagnation += 1
        else:
            stagnation = 0

        if stagnation >= MAX_STAGNATION:
            print("Stopping: no further progress")
            return

        previous_error = current_error
        error = current_error

    print("FAILED: Max attempts reached")


if __name__ == "__main__":
    main()

generator.py

Generates repository via LLM.

def generate_repo(error=None):
    return """
{
  "backend/go.mod": "module backend\\n\\ngo 1.20\\n",

  "backend/cmd/server/main.go": "package main\\n\\nimport (\\n\\t\\"encoding/json\\"\\n\\t\\"fmt\\"\\n\\t\\"net/http\\"\\n\\t\\"strconv\\"\\n\\t\\"strings\\"\\n)\\n\\ntype Note struct {\\n\\tID int `json:\\"id\\"`\\n\\tContent string `json:\\"content\\"`\\n}\\n\\nvar notes = []Note{}\\nvar nextID = 1\\n\\nfunc enableCORS(w http.ResponseWriter) {\\n\\tw.Header().Set(\\"Access-Control-Allow-Origin\\", \\"*\\")\\n\\tw.Header().Set(\\"Access-Control-Allow-Methods\\", \\"GET, POST, PUT, DELETE, OPTIONS\\")\\n\\tw.Header().Set(\\"Access-Control-Allow-Headers\\", \\"Content-Type\\")\\n}\\n\\nfunc notesHandler(w http.ResponseWriter, r *http.Request) {\\n\\tenableCORS(w)\\n\\tif r.Method == http.MethodOptions { return }\\n\\n\\tswitch r.Method {\\n\\tcase http.MethodGet:\\n\\t\\tjson.NewEncoder(w).Encode(notes)\\n\\n\\tcase http.MethodPost:\\n\\t\\tvar n Note\\n\\t\\tjson.NewDecoder(r.Body).Decode(&n)\\n\\t\\tn.ID = nextID\\n\\t\\tnextID++\\n\\t\\tnotes = append(notes, n)\\n\\t\\tjson.NewEncoder(w).Encode(n)\\n\\t}\\n}\\n\\nfunc noteByIDHandler(w http.ResponseWriter, r *http.Request) {\\n\\tenableCORS(w)\\n\\tidStr := strings.TrimPrefix(r.URL.Path, \\"/notes/\\")\\n\\tid, _ := strconv.Atoi(idStr)\\n\\n\\tfor i, n := range notes {\\n\\t\\tif n.ID == id {\\n\\t\\t\\tswitch r.Method {\\n\\t\\t\\tcase http.MethodPut:\\n\\t\\t\\t\\tvar updated Note\\n\\t\\t\\t\\tjson.NewDecoder(r.Body).Decode(&updated)\\n\\t\\t\\t\\tnotes[i].Content = updated.Content\\n\\t\\t\\t\\tjson.NewEncoder(w).Encode(notes[i])\\n\\n\\t\\t\\tcase http.MethodDelete:\\n\\t\\t\\t\\tnotes = append(notes[:i], notes[i+1:]...)\\n\\t\\t\\t\\tw.WriteHeader(http.StatusOK)\\n\\t\\t\\t}\\n\\t\\t\\treturn\\n\\t\\t}\\n\\t}\\n\\tw.WriteHeader(http.StatusNotFound)\\n}\\n\\nfunc main() {\\n\\thttp.HandleFunc(\\"/notes\\", notesHandler)\\n\\thttp.HandleFunc(\\"/notes/\\", noteByIDHandler)\\n\\n\\tfmt.Println(\\"Running on :8000\\")\\n\\thttp.ListenAndServe(\\":8000\\", nil)\\n}\\n",

  "backend/cmd/server/main_test.go": "package main\\n\\nimport (\\n\\t\\"net/http\\"\\n\\t\\"net/http/httptest\\"\\n\\t\\"strings\\"\\n\\t\\"testing\\"\\n)\\n\\nfunc TestCreateNote(t *testing.T) {\\n\\treq := httptest.NewRequest(\\"POST\\", \\"/notes\\", strings.NewReader(`{\\"content\\":\\"test\\"}`))\\n\\trr := httptest.NewRecorder()\\n\\n\\thandler := http.HandlerFunc(notesHandler)\\n\\thandler.ServeHTTP(rr, req)\\n\\n\\tif rr.Code != http.StatusOK {\\n\\t\\tt.Errorf(\\"expected 200 got %d\\", rr.Code)\\n\\t}\\n}\\n",

  "frontend/package.json": "{\\"name\\":\\"frontend\\",\\"private\\":true,\\"version\\":\\"0.0.0\\",\\"type\\":\\"module\\",\\"scripts\\":{\\"dev\\":\\"vite\\"},\\"dependencies\\":{\\"react\\":\\"^18.2.0\\",\\"react-dom\\":\\"^18.2.0\\"},\\"devDependencies\\":{\\"vite\\":\\"^5.0.0\\",\\"@vitejs/plugin-react\\":\\"^4.0.0\\"}}",

  "frontend/vite.config.js": "import { defineConfig } from 'vite';import react from '@vitejs/plugin-react';export default defineConfig({plugins:[react()]});",

  "frontend/index.html": "<!doctype html><html><head><meta charset='UTF-8'><title>Notes</title></head><body><div id='root'></div><script type='module' src='/src/main.jsx'></script></body></html>",

  "frontend/src/main.jsx": "import React from 'react';import ReactDOM from 'react-dom/client';import App from './App.jsx';ReactDOM.createRoot(document.getElementById('root')).render(<React.StrictMode><App /></React.StrictMode>);",

  "frontend/src/App.jsx": "import { useEffect, useState } from 'react';export default function App(){const [notes,setNotes]=useState([]);const [text,setText]=useState('');const fetchNotes=async()=>{try{const r=await fetch('http://localhost:8000/notes');const d=await r.json();setNotes(Array.isArray(d)?d:[]);}catch(e){console.error(e);setNotes([]);}};useEffect(()=>{fetchNotes();},[]);const add=async()=>{try{await fetch('http://localhost:8000/notes',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({content:text})});setText('');fetchNotes();}catch(e){console.error(e);}};const update=async(id)=>{const newText=prompt('Update note');if(!newText)return;try{await fetch(`http://localhost:8000/notes/${id}`,{method:'PUT',headers:{'Content-Type':'application/json'},body:JSON.stringify({content:newText})});fetchNotes();}catch(e){console.error(e);}};const del=async(id)=>{try{await fetch(`http://localhost:8000/notes/${id}`,{method:'DELETE'});fetchNotes();}catch(e){console.error(e);}};return(<div style={{padding:20}}><h1>Notes</h1><input value={text} onChange={e=>setText(e.target.value)}/><button onClick={add}>Add</button><ul>{notes.map(n=>(<li key={n.id}>{n.content} <button onClick={()=>update(n.id)}>Edit</button> <button onClick={()=>del(n.id)}>Delete</button></li>))}</ul></div>);}"
}
"""

executor.py

Runs backend.

import subprocess
import os
import time
import requests


def run_backend(workdir):
    backend_path = os.path.join(workdir, "backend")

    # Ensure Go modules are ready
    subprocess.run(["go", "mod", "tidy"], cwd=backend_path)

    process = subprocess.Popen(
        ["go", "run", "./cmd/server"],
        cwd=backend_path,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )

    # --------------------------------------------------
    # WAIT FOR SERVER TO BE READY
    # --------------------------------------------------
    for _ in range(10):
        try:
            r = requests.get("http://localhost:8000/notes")
            if r.status_code == 200:
                return True, process, ""
        except Exception:
            pass

        time.sleep(0.5)

    # --------------------------------------------------
    # IF NOT READY → REAL ERROR
    # --------------------------------------------------
    out, err = process.communicate()

    print("\nBACKEND ERROR:")
    print(err or out)

    return False, None, err or out


def stop_backend(process):
    if process:
        process.terminate()
        try:
            process.wait(timeout=2)
        except Exception:
            process.kill()
tester.py
Tests

import subprocess
import os


def run_tests(workdir):
    backend_path = os.path.join(workdir, "backend")

    result = subprocess.run(
        ["go", "test", "./..."],
        cwd=backend_path,
        capture_output=True,
        text=True
    )

    if result.returncode == 0:
        return True, ""

    return False, result.stdout + result.stderr

validator.py

Performs HTTP validation.

import requests

BASE = "http://localhost:8000"


def validate_api():
    try:
        r = requests.post(f"{BASE}/notes", json={"content": "hello"})
        note = r.json()
        note_id = note["id"]

        requests.get(f"{BASE}/notes")
        requests.put(f"{BASE}/notes/{note_id}", json={"content": "updated"})
        requests.delete(f"{BASE}/notes/{note_id}")

        return True, ""

    except Exception as e:
        return False, str(e)

installer.py

Handles environment fixes.

import subprocess
import sys
import os
import re


def install_missing(error: str | None, workdir: str) -> bool:
    """
    Attempts to fix environment/dependency issues based on error output.

    Returns:
        True  -> something was installed/fixed
        False -> nothing actionable
    """

    if not error:
        return False

    error_lower = error.lower()

    backend_path = os.path.join(workdir, "backend")
    frontend_path = os.path.join(workdir, "frontend")

    # --------------------------------------------------------
    # GO MODULE ISSUES
    # --------------------------------------------------------
    if "go.mod file not found" in error_lower:
        print("[installer] Initializing go module")

        subprocess.run(
            ["go", "mod", "init", "backend"],
            cwd=backend_path
        )

        subprocess.run(
            ["go", "mod", "tidy"],
            cwd=backend_path
        )

        return True

    if "cannot find module" in error_lower or "no required module provides package" in error_lower:
        print("[installer] Running go mod tidy")

        subprocess.run(
            ["go", "mod", "tidy"],
            cwd=backend_path
        )

        return True

    # --------------------------------------------------------
    # NPM / FRONTEND
    # --------------------------------------------------------
    if "npm" in error_lower or "node_modules" in error_lower:
        if os.path.exists(frontend_path):
            print("[installer] Installing npm dependencies")

            subprocess.run(
                ["npm", "install"],
                cwd=frontend_path
            )
            return True

    # --------------------------------------------------------
    # PYTHON MODULE (requests etc.)
    # --------------------------------------------------------
    if "no module named" in error_lower:
        try:
            pkg = re.findall(r"No module named ['\"](.+?)['\"]", error)[0]
        except:
            return False

        # Avoid installing internal modules
        if pkg.startswith(("agent", "backend", "frontend")):
            print(f"[installer] Skipping internal module: {pkg}")
            return False

        print(f"[installer] Installing python package: {pkg}")

        subprocess.run(
            [sys.executable, "-m", "pip", "install", pkg]
        )

        return True

    return False

utils.py

Writes files.

import os
import shutil


def write_files(base, file_map: dict):
    # CLEAN previous generation
    if os.path.exists(base):
        shutil.rmtree(base)

    os.makedirs(base, exist_ok=True)

    # Write fresh files
    for path, content in file_map.items():
        full_path = os.path.join(base, path)

        os.makedirs(os.path.dirname(full_path), exist_ok=True)

        with open(full_path, "w") as f:
            f.write(content)

config.py

import os

WORKDIR = "project_agentic_coded_full_system_go"

MAX_ATTEMPTS = 5
MAX_STAGNATION = 2

SERVER_START_DELAY = 2
PORT = 8000

.gitignore

What should not get into the Git repository

# Python
__pycache__/
*.pyc
*.pyo
*.pyd

# Virtual env
.venv/
venv/

# Generated projects (ignore agent output)
project_agentic_coded_full_system_go/

# OS
.DS_Store

Appendix B — Backend Generated Example (Go)

main.go (simplified)

http.HandleFunc("/notes", notesHandler)
http.HandleFunc("/notes/", noteByIDHandler)

Supports:

GET
POST
PUT
DELETE

Includes:

in-memory store
JSON encoding
CORS headers

Appendix C — Frontend Example (React)
Features:

fetch notes
create note
update note
delete note
Uses fetch API.

Appendix D — Iteration Strategy

Problem

Fixed loops:

stop too early
waste iterations

Solution

MAX_ATTEMPTS = 10
MAX_STAGNATION = 2

Behavior

stop on success
stop on stagnation
bounded retries

Final Takeaway

This approach moves development from:
code generation → system generation

The agent becomes:

builder
tester
validator
debugger

Full Modular System Example Git Repository

In this Git repository you can clone the implentation of this Agent.

GitHub - mmmattos/agentic-coding-full-system-go: Agentic Coding for full system in Go: Backend and…
Agentic Coding for full system in Go: Backend and Frontend - mmmattos/agentic-coding-full-system-go
github.com

From Single Files to Full Systems: Agentic Coding for Complete Repositories

Miguel Miranda de Mattos — Thu, 30 Apr 2026 23:36:50 +0000

Introduction

In earlier experiments, we explored a simple but powerful idea:

An agent can generate code, run it, observe failures, and iteratively fix itself.

That approach worked well for single-file applications across Python, Go, and TypeScript.

But real systems are not single files.

They are:

structured\
layered\
multi-module\
opinionated

This raises a deeper question:

Can agents generate complete repositories — — not just code?

In this article, we push agentic coding one step further:

👉 generating a Clean Architecture notes application
👉 as a multi-file Python project
👉 verified with unit tests (pytest)

The Shift: From Code to Systems
system = structure + boundaries + contracts + code

Target Architecture

project_agent_coded_python_clean_arch/
  domain/
    models.py0
  application/
    services.py
  infrastructure/
    db.py
  api/
    main.py
  tests/
    test_notes.py

The Agent Evolution

generate → run → validate → test → fix

Running the Agent

python agent_coder_python_clean_arch.py

The agent will:

generate the full project structure\
install dependencies\
start the API\
execute tests\
fix issues iteratively

Generated Project
project_agent_coded_python_clean_arch/

Run Generated API

cd project_agent_coded_python_clean_arch
python api/main.py

Run Tests

cd project_agent_coded_python_clean_arch
pytest

Generated Unit Tests

from fastapi.testclient import TestClient
from api.main import app
client = TestClient(app)
def test_create_note():
    response = client.post("/notes", json={"content": "test"})
    assert response.status_code in (200, 201)
    data = response.json()
    assert "id" in data
    assert data["content"] == "test"
def test_get_notes():
    response = client.get("/notes")
    assert response.status_code == 200
    assert isinstance(response.json(), list)

Why This Matters

From: code generation
To: verified system construction

Appendix A — — FULL AGENT CODE

import os
import subprocess
import time
import json
import sys
from openai import OpenAI
# ============================================================
# CONFIGURATION
# ============================================================
client = OpenAI()
WORKDIR = "project_agent_coded_python_clean_arch"
os.makedirs(WORKDIR, exist_ok=True)
GOAL = """
Build a Clean Architecture notes REST API in Python.
Structure:
- domain/models.py
- application/services.py
- infrastructure/db.py
- api/main.py
- tests/test_notes.py
Requirements:
- Use FastAPI
- Use SQLite
- POST /notes
- GET /notes
- Include pytest tests
- Must run with: python api/main.py
"""
# ============================================================
# CODE GENERATION
# ============================================================
def generate_repo(goal, error=None):
    """
    Generate a full multi-file repository using the LLM.
The model must return a JSON object mapping file paths → file contents.
Args:
        goal (str): High-level system description
        error (str | None): Feedback from previous attempt
Returns:
        str: Raw JSON string (must be parsed)
    """
prompt = f"""
You are an autonomous coding agent.
Goal:
{goal}
Return ONLY valid JSON mapping file paths to contents.
Rules:
- No markdown
- All files must be included
- Tests must use pytest
- Code must run without modification
Previous error:
{error}
"""
response = client.responses.create(
        model="gpt-4.1-mini",
        input=prompt
    )
return response.output_text
# ============================================================
# FILE SYSTEM OPERATIONS
# ============================================================
def write_files(file_map):
    """
    Write generated files to disk.
Creates directories as needed.
Args:
        file_map (dict): { path: content }
    """
    for path, content in file_map.items():
        full_path = os.path.join(WORKDIR, path)
os.makedirs(os.path.dirname(full_path), exist_ok=True)
with open(full_path, "w") as f:
            f.write(content)
# ============================================================
# RUNTIME EXECUTION
# ============================================================
def run_app():
    """
    Start the generated API.
Returns:
        (success, process, error)
Success means the server started and did not crash immediately.
    """
process = subprocess.Popen(
        [sys.executable, "api/main.py"],
        cwd=WORKDIR,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True
    )
# Give the server time to start
    time.sleep(3)
# If still running → success
    if process.poll() is None:
        return True, process, ""
# Otherwise, capture failure
    stdout, stderr = process.communicate()
    return False, None, stderr
def stop_app(process):
    """
    Stop the running API process.
    """
    if process:
        process.terminate()
# ============================================================
# VALIDATION (PRIMARY = PYTEST)
# ============================================================
def run_tests():
    """
    Execute pytest inside the generated project.
This is the PRIMARY validation mechanism.
Returns:
        (bool, str):
            - success flag
            - error output (if any)
    """
result = subprocess.run(
        [sys.executable, "-m", "pytest"],
        cwd=WORKDIR,
        capture_output=True,
        text=True
    )
if result.returncode == 0:
        return True, ""
return False, result.stdout + result.stderr
# ============================================================
# DEPENDENCY HEALING
# ============================================================
def install_missing(error):
    """
    Attempt to auto-install missing dependencies.
The agent inspects error messages and installs packages dynamically.
Returns:
        bool: whether a fix attempt was made
    """
if not error:
        return False
if "No module named" in error:
        pkg = error.split("'")[1]
        subprocess.run([sys.executable, "-m", "pip", "install", pkg])
        return True
if "pytest" in error:
        subprocess.run([sys.executable, "-m", "pip", "install", "pytest"])
        return True
return False
# ============================================================
# ENVIRONMENT PREPARATION
# ============================================================
def clean_port():
    """
    Kill any process using port 8000.
Prevents conflicts between agent iterations.
    """
    subprocess.run(
        "lsof -ti :8000 | xargs kill -9",
        shell=True,
        stdout=subprocess.DEVNULL,
        stderr=subprocess.DEVNULL
    )
# ============================================================
# AGENT EXECUTION LOOP
# ============================================================
"""
============================================================
AUTONOMOUS AGENT LOOP
This loop implements a full self-healing coding cycle:
1. Generate repository from goal
    2. Write files to disk
    3. Run the generated API
    4. Validate using pytest
    5. Feed errors back into the model
    6. Repeat until success
IMPORTANT DESIGN DECISIONS:
- pytest is the PRIMARY validation mechanism
- HTTP validation (Appendix B) is optional and NOT used here
- The agent stops ONLY when tests pass
============================================================
"""
clean_port()
error = None
for attempt in range(5):
print(f"\n--- Attempt {attempt+1} ---")
# --------------------------------------------------------
    # STEP 1: GENERATE CODE
    # --------------------------------------------------------
    raw = generate_repo(GOAL, error)
try:
        file_map = json.loads(raw)
    except Exception:
        error = "Invalid JSON output"
        continue
# --------------------------------------------------------
    # STEP 2: WRITE FILES
    # --------------------------------------------------------
    write_files(file_map)
# --------------------------------------------------------
    # STEP 3: RUN APPLICATION
    # --------------------------------------------------------
    success, process, err = run_app()
if not success:
        # Try to fix missing dependencies
        if install_missing(err):
            error = err
            continue
error = err
        continue
# --------------------------------------------------------
    # STEP 4: VALIDATE USING PYTEST
    # --------------------------------------------------------
    test_ok, test_error = run_tests()
# Stop API before continuing
    stop_app(process)
if test_ok:
        print("\nSUCCESS: All tests passed. System is valid.")
        break
# --------------------------------------------------------
    # STEP 5: SELF-HEALING LOOP
    # --------------------------------------------------------
    if install_missing(test_error):
        error = test_error
        continue
# Feed test failures back into next generation
    error = test_error
Appendix B — — Optional API Validation
import requests
def validate_api():
    try:
        r = requests.get("http://localhost:8000/notes")
        if r.status_code != 200:
            return False, r.text
        return True, ""
    except Exception as e:
        return False, str(e)

Conclusion

This is no longer code generation.

This is autonomous system construction with verification.

Full Modular Agent Code Example

https://github.com/mmmattos/agentic-coding-python-clean-arch

Is Experience overlooked in Tech?

Miguel Miranda de Mattos — Thu, 30 Apr 2026 23:13:53 +0000

I’ve been reflecting on something in today’s tech hiring market.
There seems to be a gap between how much companies say they value experienced engineers and how often highly experienced professionals move forward in hiring processes.

In areas like backend development, software architecture, and data systems (ETL pipelines, data platforms), experience often translates into:

Download the Medium App
• better architectural decisions
• awareness of trade-offs
• ability to anticipate risks
• mentoring and team support

More recently, many of these professionals are also expanding into areas like Generative AI.

It raises an interesting question:

Are we fully leveraging one of the most valuable assets in tech — experience?
Curious to hear how others see this.

You’re Not Writing Code Anymore — You’re Designing Agents

Miguel Miranda de Mattos — Thu, 30 Apr 2026 22:24:29 +0000

Why senior engineers must rethink the development loop in the age of autonomous systems
The Shift Is Already Happening
For decades, software engineering has been a story of abstraction:

assembly → high-level languages
servers → cloud platforms
scripts → pipelines
Agentic coding is the next step — but this time, the abstraction is not over infrastructure.

It is over the act of development itself.

You are no longer just writing code.
You are designing systems that write, run, and fix code.

The Moment Everything Changes
Most engineers today have used AI coding assistants.

They autocomplete. They suggest. They accelerate.

But they stop here:

Here is the code.
Agentic systems cross that boundary.

They operate in a loop:

Goal → Generate → Execute → Observe → Fix → Repeat

And crucially:

They do not stop until the system works.

Start Small: The Fibonacci Agent

Goal:

Write a Python script that computes Fibonacci numbers

def generate(goal, error=None):
    return llm(goal + (f"\nFix error: {error}" if error else ""))
while True:
    code = generate("fibonacci")
    try:
        exec(code)
        break
    except Exception as e:
        error = str(e)

This is the smallest useful agent.

The Core Loop (The Real Abstraction)

while not success:
    code = generate(goal, error)
    write(code)
    rc, out, err = run()
    error = err

This loop is:
a compiler
a debugger
a DevOps pipeline
a junior engineer

Minions vs Stripes

Minions (WHAT):

run code
install dependencies
write files

Stripes (HOW):

retry loop
error handling
decision flow

Architecture: Minimal Autonomous Coding System

      +------------------+
      |       LLM        |
      +------------------+
                ↓
      +------------------+
      |   Code Generator |
      +------------------+
                ↓
      +------------------+
      |   File System    |
      +------------------+
                ↓
      +------------------+
      |   Runtime        |
      +------------------+
                ↓
      +------------------+
      |  Error Feedback  |
      +------------------+
                ↓
           Control Loop

Extended with:

Dependency Installer (pip/npm/go)
Process Manager (servers, timeouts)
Retry Strategy (stripe)

The Experiment: One Goal, Three Implementations

Build a REST API that stores user notes
The objective was not just to generate code, but to:

1. execute it
2. resolve failures
3. adapt to each ecosystem
4. reach a running system autonomous ly

We then applied the same loop across:

Python (FastAPI)
Go (net/http)
TypeScript (Express)
The goal stayed the same. Only the environment changed.

Full working implementations:

https://github.com/mmmattos/agentic-coding-demo

Python Agent (FastAPI)

import subprocess, re, os, time
from openai import OpenAI
client = OpenAI()
WORKDIR = "python_agent"
FILENAME = os.path.join(WORKDIR, "app.py")
os.makedirs(WORKDIR, exist_ok=True)
def generate(goal, error=None):
    prompt = f"Build a FastAPI notes API. Fix errors: {error}"
    r = client.responses.create(model="gpt-4.1-mini", input=prompt)
    return r.output_text
def run():
    p = subprocess.Popen(["python", "app.py"], cwd=WORKDIR,
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    time.sleep(3)
    if p.poll() is None:
        return 0, "", ""
    out, err = p.communicate()
    return p.returncode, out, err
def fix(err):
    m = re.search(r"No module named '(.+?)'", err)
    if m:
        subprocess.run(["pip", "install", m.group(1)])
        return True
    return False
error = None
for _ in range(5):
    code = generate("REST API", error)
    open(FILENAME, "w").write(code)
    rc, out, err = run()
    if rc == 0:
        break
    if fix(err):
        continue
    error = err

Go Agent

import subprocess, re, os, time
from openai import OpenAI
client = OpenAI()
WORKDIR = "go_agent"
FILENAME = os.path.join(WORKDIR, "main.go")
os.makedirs(WORKDIR, exist_ok=True)
def generate(goal, error=None):
    prompt = f"Build a Go REST API with net/http. Fix errors: {error}"
    r = client.responses.create(model="gpt-4.1-mini", input=prompt)
    return r.output_text
def run():
    p = subprocess.Popen(["go", "run", "main.go"], cwd=WORKDIR,
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    time.sleep(3)
    if p.poll() is None:
        return 0, "", ""
    out, err = p.communicate()
    return p.returncode, out, err
def fix(err):
    if "go.mod file not found" in err:
        subprocess.run(["go", "mod", "init", "notesapi"], cwd=WORKDIR)
        return True
    m = re.search(r"no required module provides package (.+?);", err)
    if m:
        subprocess.run(["go", "get", m.group(1)], cwd=WORKDIR)
        return True
    return False
error = None
for _ in range(5):
    code = generate("REST API", error)
    open(FILENAME, "w").write(code)
    rc, out, err = run()
    if rc == 0:
        break
    if fix(err):
        continue
    error = err

TypeScript Agent

import subprocess, os, re, time
from openai import OpenAI
client = OpenAI()
WORKDIR = "ts_agent"
FILENAME = os.path.join(WORKDIR, "server.ts")
os.makedirs(WORKDIR, exist_ok=True)
def generate(goal, error=None):
    prompt = f"Build an Express TypeScript REST API. Fix errors: {error}"
    r = client.responses.create(model="gpt-4.1-mini", input=prompt)
    return r.output_text
def setup():
    if not os.path.exists(os.path.join(WORKDIR, "package.json")):
        subprocess.run(["npm", "init", "-y"], cwd=WORKDIR)
        subprocess.run(["npm", "install", "express", "sqlite3"], cwd=WORKDIR)
        subprocess.run(["npm", "install", "-D", "typescript", "ts-node", "@types/node", "@types/express"], cwd=WORKDIR)
def run():
    p = subprocess.Popen(["npx", "ts-node", "server.ts"], cwd=WORKDIR,
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    time.sleep(3)
    if p.poll() is None:
        return 0, "", ""
    out, err = p.communicate()
    return p.returncode, out, err
def fix(err):
    m = re.search(r"Cannot find module '(.+?)'", err)
    if m:
        subprocess.run(["npm", "install", m.group(1)], cwd=WORKDIR)
        return True
    return False
setup()
error = None
for _ in range(5):
    code = generate("REST API", error)
    open(FILENAME, "w").write(code)
    rc, out, err = run()
    if rc == 0:
        break
    if fix(err):
        continue
    error = err

The Real Insight

The agent is not fixing code.
It is fixing the system.

Failures were environmental:

missing dependencies
missing modules
runtime mismatches
process lifecycle

The hardest part of software engineering is not writing code — it’s making systems work.

Unattended agentic coding is the first serious attempt to automate that entire loop.

Key Topics for Next Articles
In this article we have scratched the surface of agentic coding .
In upcoming articles, we'll cover the following topics:

1.Multi-file & Repository-Aware Agents
Move from single-file generation to full project structures (modules, configs, folders).

2.Stateful & Incremental Code Editing
Agents that read, modify, and improve existing code instead of regenerating from scratch.

3.Test-Driven Agentic Development
Shift from “it runs” → “it works” by validating behavior via API calls, tests, and assertions.

4.Robust Environment & Tooling Orchestration
Handling real-world constraints (Python, Node, nvm, dependencies, ports) reliably.

5.Multi-Agent Architectures (Minions & Stripes)
Introduce specialized agents (planner, coder, tester, fixer) collaborating toward a goal.

Observability, Metrics & Feedback Loops Track attempts, failures, convergence, and use richer signals (logs, responses, tests) to guide agents.

Full Code & Examples
https://github.com/mmmattos/agentic-coding-demo

Concurrency Models in Practice: Node.js vs Go vs Python

Miguel Miranda de Mattos — Wed, 29 Apr 2026 21:41:13 +0000

Most systems don’t fail because of syntax — they fail because of how they handle flow.

At scale, software is no longer just about executing logic. It’s about orchestrating movement: requests, data, and work units flowing through a system under pressure. Different runtimes don’t just process tasks — they shape how work moves. And those choices define whether your system degrades gracefully… or collapses under load.

A Pragmatic Guide for Scalable Systems

Most systems don’t fail because of syntax. They fail because of poor decisions around concurrency and scaling.

If you’re building systems that need to handle real-world load, your runtime choice is not just an implementation detail — — it’s an architectural decision.

The Core Distinction

• Concurrency = handling many tasks
• Parallelism = executing tasks simultaneously

The real question is: How does your runtime use CPU cores?

Comparative Overview

Node.js
• Event loop (non-blocking I/O)
• Scales via processes (cluster)
• 1 process = 1 core

Go
• Goroutines (lightweight tasks)
• Thousands mapped to few threads
• Efficient multi-core usage

Python
• Threads, asyncio, multiprocessing
• True parallelism only via processes
• GIL limits threading

Node.js — — Process-Level Scaling

const cluster = require(‘cluster’); if (cluster.isPrimary) { for (let i = 0; i < require(‘os’).cpus().length; i++) { cluster.fork(); } }
• Scale = replicate processes
• No shared memory
• Strong for I/O, weak for CPU

Go — — Concurrency as a Primitive

go handleRequest()
• Massive concurrency with low overhead
• Scheduler handles complexity
• Designed for high-throughput systems

Python — — Power with Constraints

Threading
threading.Thread(target=task)
Multiprocessing
Process(target=task)
Async
async def task(): …

Flexible but fragmented model
Requires deliberate architecture

Quick Comparison

Use Case Mapping

• APIs → Node.js or Go
• Streaming systems → Go
• CPU-heavy workloads → Python (multiprocessing)
• Data / ML → Python

Key Takeaways

• Node.js: simple, effective, but process-bound
• Go: best-in-class concurrency model
• Python: powerful ecosystem, weaker runtime model

Final Perspective

There is no best language — — only trade-offs.

Senior engineering is about understanding those trade-offs early:

• Workload type (I/O vs CPU)
• Scaling strategy (cores vs machines)
• Operational complexity

Modern AI tooling makes it trivial to generate working code.

But scalable systems are not the result of code generation.

They are the result of:
• Correct architectural decisions
• Appropriate concurrency models
• Deep understanding of runtime behavior

Code gets you started.

Architecture determines whether your system survives production.