A A A A AI W W W W Workflow
Human-AI symbiosis in practice
Most AI coding tools operate as autocomplete — they generate code without context, understanding, or accountability. The output looks right but doesn't trace to any requirement. There's no governance, no verification, no audit trail. The developer is left to validate everything manually, defeating the purpose of acceleration.
SBX treats AI as a supervised partner. Claude Code agents operate within governance boundaries defined by hooks, skills, and decision records. The AI loads knowledge artifacts, follows SDLC discipline, and produces traceable output. The human sets direction, reviews decisions, and owns the final product. The result is not faster typing — it's faster decision-making with full accountability.
Supervised Partnership, Not Autopilot
The human defines goals and reviews output. The AI loads governance context, follows the SDLC pipeline, and implements within defined boundaries. Every AI-generated artifact is verified before entering the codebase — build evidence, runtime proof, and conformance checks are mandatory, not optional. This creates accountability: the human owns the product, the AI accelerates the execution. Neither operates without the other.
Human Role
- Set direction and define goals
- Review architectural decisions
- Own the product and final output
- Approve pull requests
- Define governance boundaries
AI Role
- Load knowledge before implementing
- Follow SDLC state machine
- Implement within defined scope
- Generate tests and fixtures
- Report with build + runtime proof
Governance Layer
- Hooks enforce git and CLI rules
- Skills provide structured workflows
- Decisions record rationale immutably
- Memory persists context across sessions
- Conformance gates block non-compliant work
What the AI Cannot Do
The AI cannot push to main, cannot skip SDLC steps, cannot deploy to production, cannot bypass conformance gates. These constraints are enforced by git hooks, bash deny hooks, and SDLC state machine validation — not by trust or convention, but by code that blocks non-compliant operations at runtime. The boundaries are not limitations. They are the safety net that makes high-speed AI-augmented development sustainable.
Every Session is Structured
AI sessions follow a consistent lifecycle: workspace orientation, knowledge loading, SDLC task initialization, implementation with governance, verification with proof, and session retrospective. No free-form coding — every session produces auditable output. The structure ensures that context survives across sessions, mistakes are recorded for future avoidance, and every artifact traces back to its origin.
Orientation
sbx describe loads the 826-node workspace tree. sbx help provides the full CLI reference. The AI understands what exists before touching anything.
Knowledge Load
sbx knowledge list/get loads applicable patterns, standards, guidelines, and solutions. Every implementation decision is informed by existing governance artifacts.
Task Init
sbx sdlc init creates a governed task with scope classification — which applications, packages, and platforms are affected. The state machine begins.
Implementation
Step-by-step progression through the FDD pipeline. Knowledge artifacts load at each gate. Every file traces to a user story. No free-form coding.
Verification
Build output, runtime evidence, HTTP status codes, screenshots. Never "done" without proof. The AI validates its own work before reporting.
Retrospective
Session commit with structured reflection — what went well, mistakes made, root patterns identified, and status carried forward to the next session.
Impact at Scale
These numbers demonstrate the productivity multiplier of governed AI workflows: 222+ architectural decisions recorded with rationale and alternatives, 352+ knowledge artifacts maintained as living governance, 292+ pull requests shipped through the governed pipeline. This is not AI replacing humans — it is AI making human decisions faster and more traceable. Every number represents a verifiable artifact in the repository.