Shifting from Workgentic to Agentic Workflow

The single biggest misconception is thinking agentic development is just "prompt engineering." A prompt is static text; a control loop is an active feedback circuit between objective, action, environment, and evidence.

THE OLD CONTROL LOOP:
Human ───► Code ───► Compiler/Interpreter ───► Result

THE AGENTIC CONTROL LOOP:
Human ───► Objective & Constraints
             │
             ▼
           Agent ◄───┐
             │       │ (Self-Correction & Diagnosis)
             ▼       │
       Code & Commands
             │       │
             ▼       │
        Environment  │
             │       │
             ▼       │
          Evidence ──┘
             │
             ▼
       Human Oversight & Approval
        

Every effective agentic task delegation must supply five distinct pillars:

1. Objective: The specific business outcome to achieve.
2. Scope: The explicit repository boundaries and target directories.
3. Constraints: What existing systems or schemas must not be broken or altered.
4. Proof Mechanism: Which test suite, linter, or health check must be executed.
5. Evidence: The terminal logs, test report, or git diff that must be presented.

Valid evidence requires concrete, external artifacts produced by deterministic processes:

• Automated test suites passed with exit code 0
• Linter and static analysis checks clean
• HTTP server healthy on localhost probe
• Database queries showing expected mutated row states
• DOM rendering checked via headless browser automation
• Inspected, atomic git diffs free of unintended regressions

When an agent fails, human developers often instinctively copy and paste errors into chat. This reduces the human to an error courier. Instead, equip the agent directly with observability tools:

Don't just give an agent tools in an unstructured workspace. Build a standardized environment that facilitates automatic discovery and self-testing:

PROJECT/
├── source/         # Production application code
├── tests/          # Automated test suites (pytest, jest, vitest)
├── config/         # Environment parameters & safe defaults
├── logs/           # Dedicated directory for runtime output
├── database/       # Schema definitions & migration scripts
├── scripts/        # Reversible automation & build tools
├── documentation/  # Architecture notes, boundaries, and standards
└── diagnostics/    # Self-test scripts & health probes
        

1. DEFINE    ──► What business outcome is required?
2. INSPECT   ──► What files, systems, and tests already exist?
3. PLAN      ──► What exact changes does the agent intend to make?
4. EXECUTE   ──► Agent applies targeted file edits.
5. TEST      ──► Run automated unit and integration tests.
6. OBSERVE   ──► Examine terminal output, logs, and exit codes.
7. DIAGNOSE  ──► If a failure occurs, trace root cause before editing.
8. CORRECT   ──► Apply minimal surgical repair.
9. VALIDATE   ──► Rerun full regression test suite.
10. REVIEW   ──► Human inspects git diff and evidence report.
        

This 10-phase cycle forms the operational engine of every autonomous coding system in the BuildBotsBetter fleet.

Taking over and fixing the code by hand destroys the learning loop and returns you to the workgentic bottleneck. When an error occurs, guide the agent through this disciplined 8-step recovery:

1. Step 1: Capture the failure — Save the exact stack trace, test error, and console output.
2. Step 2: Provide the evidence — Feed the raw failure output directly to the agent.
3. Step 3: Mandate diagnosis first — Require the agent to explain the error before modifying any code.
4. Step 4: Identify root cause — Confirm the underlying bug rather than patching superficial symptoms.
5. Step 5: Propose the repair — Have the agent outline the minimal diff needed.
6. Step 6: Implement fix — Apply the corrective change to the codebase.
7. Step 7: Reproduce and retest — Run the failing test to prove resolution.
8. Step 8: Check regression suite — Run the entire project test suite to verify no collateral damage.

In the old workflow, a developer sees an error, copies the text, pastes it into a chat box, copies the AI response, and pastes it into the editor. This turns you into an expensive human message bus.

In an agentic workflow, you design scripts and harness configurations so the agent runs the command, observes the non-zero exit code, reads the log file directly, checks the git history to see what was recently edited, and formulates a hypothesis on its own.

As an Agentic Developer, your responsibilities include:

• Defining crisp, unambiguous system objectives
• Setting architecture, security, and schema boundaries
• Providing context, documentation, and debugging tools
• Establishing automated verification and quality gates
• Supervising multi-agent coordination and peer reviews
• Auditing git diffs for correctness, readability, and performance

To prepare for autonomous execution, create the standard four scaffolding components in your project:

1. AGENTS.md / Instructions: Clear project overview, rules of engagement, and commands.
2. Testing Harness: Fast automated test suite (e.g., pytest, jest, node --check).
3. Logging Infrastructure: Central logs directory with timestamped execution records.
4. CI/CD Gate: A single repeatable script (e.g. cicd.py) that verifies syntax, tests, and diffs.

As the Technical Overseer, follow the full agentic supervision sequence:

1. Inspect Evidence: Review the failing test trace and recent uncommitted diffs.
2. Direct the Agent: Formulate an agentic delegation prompt providing the test failure trace and requiring root cause diagnosis.
3. Review Diagnosis: Ensure the agent correctly identifies why the logic broke before allowing it to edit files.
4. Oversee Repair: Let the agent apply the fix and rerun the test suite.
5. Verify Evidence: Check that all tests pass, exit code is 0, and the git diff is minimal and safe.

1. Per-Agent Onboarding Checklist

Run this six-line checklist for every agent before delegating tasks:

$check = Join-Path $env:TEMP "bbb-onboarding-checklist.txt"; @("agent:","rules file:","memory location:","permissions:","delete guard:","backup path:","final check:") | Set-Content -Encoding ascii $check; Get-Content $check; Write-Host "Fill every line for this agent. Rerun this checklist for the next agent."

2. Variable-Limit Delete Guard Demo

Prove why text guards miss variable-stored paths and why path-resolving PreToolUse hooks are mandatory:

$tmp = $env:USERPROFILE; $literal = $env:USERPROFILE; foreach ($src in @('$tmp','$env:GROK_HOME','python cleanup.py')) { if ($src -like "*$literal*") { "HIT $src" } else { "MISS $src" } }; if ([IO.Path]::GetFullPath($tmp) -eq [IO.Path]::GetFullPath($env:USERPROFILE)) { "REFUSE resolved tmp: it is the user profile. Text guards miss dollar-variables and python cleanup.py. 2026-09-23 Remove-Item of user profile is the example." }

3. Off-Volume Profile & Fleet Backups

Back up all agent configuration roots (.agy, .claude, .codex, .grok) to D:\Backups\llm-profiles:

$dest = "D:\Backups\llm-profiles\$(Get-Date -Format yyyyMMdd-HHmm)"
New-Item -ItemType Directory -Force -Path $dest | Out-Null
foreach ($d in @(".agy", ".claude", ".codex", ".grok")) {
  if (Test-Path "$env:USERPROFILE\$d") {
    robocopy "$env:USERPROFILE\$d" "$dest\$d" /E /NFL /NDL /NJH /NJS
    Write-Host "Backed up $dest\$d"
  }
}
Get-ChildItem $dest

4. Practised Restore Drill

Verify backup recoverability with this non-destructive drill in your temp folder:

$drill = Join-Path $env:TEMP "bbb-restore-drill"; $src = Join-Path $drill "source"; $bak = Join-Path $drill "backup"; $back = Join-Path $drill "restored"; New-Item -ItemType Directory -Force -Path $src,$bak,$back | Out-Null; Set-Content -Encoding ascii -Path (Join-Path $src "proof.txt") -Value "bbb-restore-proof"; Copy-Item (Join-Path $src "proof.txt") (Join-Path $bak "proof.txt"); Remove-Item (Join-Path $src "proof.txt"); Copy-Item (Join-Path $bak "proof.txt") (Join-Path $back "proof.txt"); Get-Content (Join-Path $back "proof.txt"); Write-Host "Practised restore wrote proof into $back. Do not delete your user profile to test this."

5. Fail-Closed Workspace Policy

Autonomous agent work roots must always fail closed to designated project directories like C:\My Projects. Never delegate unattended tasks with blanket approvals in the user home directory.