Architecting Autonomous Software Development: Implementing the UltraCode Dynamic Workflow Pattern with Claude Fable 5
The paradigm of software engineering is shifting from manual instruction-following to high-level orchestration. The emergence of "Agentic Operating Systems" (Agentic OS) allows for a transition where developers no longer write lines of code, but rather manage complex, multi-agent workflows that execute autonomously. This post explores the technical implementation of GenTechOS, an agentic framework leveraging Anthropic’s Claude Fable 5 and the UltraCode Dynamic Workflow pattern to automate the entire Software Development Life Cycle (SDLC) via GitHub Project boards.
The Shift from Headless Claude to UltraCode Dynamic Workflows
Previously, many agentic implementations relied on headless Claude subscriptions to drive automation. However, due to shifts in API support for certain headless configurations within standard subscriptions, a more robust architectural pattern has emerged: the UltraCode Dynamic Workflow.
Unlike static prompting, the UltraCode pattern utilizes an orchestrator that operates on a continuous loop. This orchestrator monitors a state-management layer—in this case, a GitHub Kanban board—and triggers specialized sub-agents to process tickets through various lifecycle stages (Backlog $\rightarrow$ Building $\rightarrow$ QA $\rightarrow$ Review $\rightarrow$ Done).
Core Architecture: The Orchestrator and State Management
The GenTechOS architecture functions as a decoupled system where the UI/State layer is separated from the execution engine.
- The State Layer (GitHub Projects): Using GitHub Projects as a Kanban board provides a persistent, transparent, and mobile-accessible source of truth. Each "issue" acts as a discrete unit of work containing metadata, acceptance criteria, and technical specifications.
- The Orchestrator: A central Claude session running in an infinite loop. The orchestrator's primary logic is:
While (Kanban_Board.Status != 'Done') { Trigger_Workflow(); }. - The Execution Engine (Superboard): This is the backend implementation that dispatches agents based on the current column of the Kanban board.
Sub-Skill Specialization
To maintain high accuracy, the system does not use a single monolithic agent. Instead, it employs specialized sub-skills:
- Builder Skill: Utilizes Superpower for execution, following Test-Driven Development (TDD) principles to ensure code meets the defined acceptance criteria.
- QA Skill: Implements Playwright-based automated testing and integrates with tools like G-Stack to verify functional requirements.
- Reviewer Skill: Performs deep semantic analysis of the Pull Request (PR) against the original technical specification, ensuring no "spec drift" has occurred during the build phase.
Deep Dive: The Six Dynamic Workflow Patterns
The efficiency of an Agentic OS is determined by its ability to select the correct computational pattern for a given task. Within GenTechOS, we implement several sophisticated patterns:
1. Classify Act
This pattern optimizes cost and latency by performing a preliminary classification step using a lightweight model (e.g., Claude Haiku). The agent analyzes the complexity of the incoming ticket and assigns it to an appropriate model tier:
- Low Complexity: Routed to Haiku for rapid, low-cost execution.
- Medium/High Complexity: Routed to Claude Sonnet or Fable 5 for deep reasoning and complex logic implementation.
2. Fan-out and Synthesize
Used for large-scale feature implementations (e.g., building a full landing page). The orchestrator decomposes a single high-level task into multiple sub-tasks (Hero Section, Nav Bar, CTA, etc.). Multiple agents work in parallel on these components (Fan-out), and a final agent aggregates the outputs into a cohesive codebase (Synthesize).
3. Adversarial Review
This pattern introduces a "Worker vs. Verifier" tension. A sub-agent generates code (the Worker), while a separate, highly constrained agent (the Verifier) attempts to find flaws or deviations from the spec. This back-and-forth loop continues until the Verifier can no longer identify regressions.
4. Generate, Filter, and Tournament
Primarily utilized for UI/UX and design-centric tasks. The system generates multiple iterations of a component (e.g., different CSS layouts). A "Filter" agent—possessing context regarding the existing Design System—evaluates these versions. In a Tournament configuration, the system can even select multiple winning variants if they meet specific thresholds.
5. Loop Tracking (Loop Until Done)
This is the foundational pattern for the GenTechOS orchestrator. It implements a conditional loop that monitors the GitHub board's "Ready" and "Building" columns, continuously spawning agents to process tickets until the terminal state (all tasks moved to 'Done') is reached.
Implementation: The Superboard CLI
The deployment of this system is abstracted through the superboard CLI tool. The workflow follows a standardized lifecycle:
# Initialize the project environment and connect GitHub integration
superboard onboard
# Validate that all tickets contain necessary acceptance criteria (Linting)
superboard lint
# Execute the orchestrator loop
superfard run
By utilizing superboard run, the developer initiates the UltraCode Dynamic Workflow. The system begins by classifying tasks, then moves them through the Builder and QA pipelines. As seen in our demonstration of an automated email lead magnet, the system can autonomously configure a frontend, integrate with Resend for email dispatch, and implement Cloudflare Turnstile for bot protection—all without manual intervention.
Conclusion
The transition from "coding" to "orchestrating" requires a fundamental shift in how we view AI integration. By leveraging specialized models like Fable 5 through structured patterns like Fan-out/Synthesize and Adversarial Review, we can build systems capable of managing entire software lifecycles with minimal human oversight.