AI-Augmented Development

P rocess & T oolkit

Feature-driven, contract-based development powered by a structured AI workflow

My workflow is built on Feature-Driven Development (FDD), combined with modular architecture, atomic components, and contract-based systems to ensure structured and scalable development.

It is implemented through a custom environment built on top of the Claude Code CLI@claudeClaude Code CLI, extended with my SBX framework and SDLC tooling. This system guides development from requirements to deployment, with AI operating as an execution layer within defined constraints.

The approach is shaped by my experience as a tech lead—designing workflows, mentoring teams, and building knowledge systems—now formalized into a repeatable, AI-augmented process.

Departments

Explore each discipline of the AI-augmented software delivery lifecycle.

DEPT

Project Management

SDLC pipeline, user stories, decision records, goals, and traceability — structured delivery from concept to deployment.

DEPT

Design & Prototyping

Component library, brand system, UI verification, and sandbox prototyping — from wireframe to pixel-perfect implementation.

DEPT

Software Engineering

Build, test, package, and run — the core development loop with governed CLI wrappers and multi-platform support.

DEPT

Quality Assurance

Knowledge artifacts, conformance gates, traceability verification, and solution-before-code governance.

DEPT

Operations

Deployment pipelines, infrastructure management, vault secrets, R2 storage, media processing, and database migrations.

DEPT

AI Workflow

Human-AI symbiosis — how Claude Code agents, skills, and governance hooks create a supervised development partnership.

Standards Reference

Industry standards, methodologies, and design principles that govern every SBX decision.

View All 103

GOVERNANCE

Governance & Process

ISO lifecycle management, ETVX phase gates, decision frameworks, and service management standards that structure how work flows through the system.

ENGINEERING

Engineering

Feature-driven development, clean code practices, pragmatic programming, design by contract, domain modeling, and test-driven development.

ARCHITECTURE

Architecture & Modeling

Enterprise architecture frameworks, ISO architecture standards, hexagonal architecture, CQRS, and classic design patterns.

QUALITY

Quality & Testing

ISO testing and requirements standards, software quality models, test documentation, and data format standards.

SECURITY

Security & Compliance

OWASP web security, NIST guidelines, CIS benchmarks, SOC 2, GDPR data protection, and ISO information security.

AI & Automation

Anthropic AI agent patterns, context engineering research, and structured prompt design for AI-augmented development.

DESIGN

Design & Frontend

Accessibility standards, CSS layout specifications, design system methodologies, and web metadata protocols.

INFRA

Infrastructure & Delivery

12-Factor App methodology, continuous delivery, REST API standards, and media streaming protocols.

SBX

SBX Framework

Internal standards codified from industry best practices — coding, modeling, architecture, naming, verification, security, UI, and AI governance.

FDD PIPELINE

FDD1 · 01 MODEL FDD2 · 02 DESIGN FDD3 · 03 PLAN FDD4 · 04 BUILD FDD5 · 05 VERIFY

PHASE SPECIFICATION

IDX	PHASE	DESCRIPTION	ARTIFACTS	GATE
01	MODEL	Define what we're building and why. Goals set the direction, user stories capture who needs what, and domain models establish the shared language between business and code. This phase ensures every line of code traces back to a business objective. Nothing is built on assumption — every decision is anchored in a goal, a story, or a domain relationship.	GoalUserDomainSequence	PASS
ENTRY CRITERIA Business objective or feature request defined Stakeholders identified EXIT CRITERIA All stories have acceptance criteria Domain model reviewed and validated No ambiguous terms in shared vocabulary DELIVERABLES Goal definition with measurable success criteria User stories with actors, scenarios, and acceptance criteria Domain model with types, fields, and relationships Sequence diagrams for key workflows
02	DESIGN	Translate the domain model into concrete technical artifacts. Package models define Go types and exports — every package has a YAML spec before any code. Page models define routes and data flow. Persistence maps entities to database schemas with typed migrations. Infrastructure requirements are declared upfront so provisioning is deterministic and repeatable.	PackagePageDatabaseInfrastructure	PASS
ENTRY CRITERIA FDD1 domain model complete Stories prioritized for iteration EXIT CRITERIA Every entity has a package.yml model All API routes documented Migration scripts reviewed DELIVERABLES Package YAML models with types, exports, and dependencies Page route definitions with data flow Database migration scripts Infrastructure requirements (services, ports, volumes)
03	PLAN	Lock down the scope before writing code. Functional and non-functional requirements get checklisted per function — security, performance, accessibility all reviewed. Test cases define what "done" looks like before implementation starts (TDD). The user checkpoint is a mandatory approval gate where the consolidated plan is reviewed before any code is written.	FunctionalNon-functionalTestConsolidated	PASS
ENTRY CRITERIA Package and page models finalized Infrastructure provisioned or mocked EXIT CRITERIA All requirements have test coverage mapped User has approved the plan Fixture data prepared DELIVERABLES Functional requirements checklist per function Non-functional requirements (performance, security, accessibility) Test plan with cases, fixtures, and assertions Consolidated plan for user review
04	BUILD	Build bottom-up, layer by layer. Pure domain has zero I/O dependencies — just types and business logic functions. Model domain adds persistence with typed repository wrappers. Service integration connects APIs with proper error handling and credential masking. UI renders the result with server-side data loading. Each layer is testable in isolation, and cross-cutting concerns (auth, logging, error handling) are applied last.	TypeRepositoryAPISvelte	PASS
ENTRY CRITERIA Plan approved at FDD3 checkpoint All models and test fixtures ready EXIT CRITERIA All layers implemented per model Each layer has passing unit tests No lint or type errors DELIVERABLES Type definitions and business logic (pure functions) Repository implementations with typed queries API routes and adapter integrations Svelte pages with server-side data loading Cross-cutting concerns (auth, logging, error handling)
05	VERIFY	Prove the work is correct before it ships. Build must compile clean with zero warnings. Tests must pass — unit, integration, and e2e. Model-code conformance ensures the implementation is a 100% representation of the model. The governed commit includes traceability trailers linking to task IDs, decision records, and feature references. No human validation needed — the agent validates autonomously.	CleanAllModel-codeGit	PASS
ENTRY CRITERIA All FDD4 layers complete No known failing tests EXIT CRITERIA Build passes All test suites green Conformance check passes Commit pushed with trailers DELIVERABLES Clean build output (zero warnings) All tests green (unit + integration + e2e) Model-code conformance report Git commit with governance trailers (task ID, decision refs)

FDD1

MODEL

FDD2

DESIGN

FDD3

PLAN

FDD4

BUILD

FDD5

VERIFY

18 steps. Every one governed. Every one traceable.

// AI_AUGMENTED_WORKFLOW

AI-Augmented Workflow

Every feature is delivered through an AI-powered workflow where Claude Code CLI operates as a governed development agent. These capabilities define how the agent participates in each phase of delivery.

01 / 07

Governed Step-by-Step Delivery

Each step delivers a context-engineered prompt with role assignment, applicable knowledge, checklists, and acceptance criteria. The agent advances through modeling, planning, implementation, and verification — producing traceable artifacts at every phase.

// DEVELOPMENT_TOOLKIT

Development Toolkit

Every tool, package, and component is built to be reused across projects. We use what we build — shredbx.com runs on the same toolkit we deliver to clients.

Core Principles

Model Before Code

Every package has a YAML spec before any implementation code is written. The model IS the documentation. Implementation is a 100% representation of the model — all deviations are bugs.

Knowledge Before Code

Load governance artifacts — patterns, standards, guidelines — before writing any implementation. Cross-reference every decision against applicable standards.

Validate Before Reporting

Build, test, verify — then report with proof. Never claim something works without evidence. The agent validates autonomously; no human "give the go" needed.

Top-to-Bottom Only

Goals to user stories to test specs to implementation to validation. Bottom-to-top is forbidden — you cannot know what you are building without the top defined first.

// WORKSPACE_RESOURCES

Agent, Knowledge & Blog

The AI collaborator, curated knowledge library, and engineering journal that power every step of the SDLC.

// Active Collaborator on This Build

Claude Code CLI

AI-powered development agent integrated into the SBX governed SDLC. Operates within a structured state machine, following Feature-Driven Development with knowledge-before-code, model-before-code, and

57 Projects

5 Games

6 Blog posts

View Agent Profile → // Curated Knowledge Library