Showcase / AI Engineering System

AI Council

I didn't just adopt AI tools. I designed an explicit org chart for them: Claude Opus as architect, Cursor as implementer, GitHub CLI as reviewer, NotebookLM as documentation lead. Implementation is dispatched to isolated worktrees on a flat-rate subscription, so AI leverage scales without the token bill scaling with it. One human approval gate, four AI roles, one platform.

Live at Manabie Salesforce + React ~80% faster bug fix Flat-rate AI cost

What it is

A structured multi-agent SDLC, not "use AI to write code"

Running a complex enterprise form platform on Salesforce meant recurring friction: QA bugs needed fast triage, architecture calls needed structured review, documentation drifted out of sync, and every issue made me re-read context before acting. Each cycle burned roughly four hours from bug report to verified fix. The answer was not a smarter prompt. It was an explicit org chart for AI: distinct roles, defined input and output contracts, and a single human approval gate.

The team

The AI Council

Four AI agents, each with one job and a clear contract. There is never ambiguity about which tool to reach for.

Claude Opus

Architect and spec reviewer. Architecture decisions, complex tradeoffs, spec validation.

Architect

Cursor Agent

Implementation. Code generation, refactor, and test scaffolding in isolated worktrees.

Implementer

GitHub CLI

Code review. PR diff review, comment generation, approval workflow.

Reviewer

NotebookLM

Stakeholder documents. Confluence and NotebookLM sync, stakeholder-facing summaries.

Docs lead

The workflow

The 6-stage bug-fix pipeline

Before: QA files a bug, I read context, investigate, fix, review, test. Roughly four hours. After: senior-engineer involvement is concentrated in one stage, not spread across six.

Triage

Claude Code with Jira MCP reads the issue, pulls the affected code, and classifies it: blocker, regression, or enhancement.

Claude Code Jira MCP

Root cause

Trace the failure path, surface the failing invariant, and propose fix candidates.

Claude Code

Implementation

Cursor writes the fix in a throw-away isolated worktree. Nothing touches main until it is approved.

Cursor Agent

Multi-lens review

Three perspectives in sequence, each a separate structured prompt with a pass or fail verdict: correctness, security, simplicity.

Claude Code

Human approval gate

I read the summary diff and the three review verdicts, then give one approval, not six. This is a hard gate, not a suggestion.

franzy

Merge and doc sync

Merge the PR, trigger doc sync to Confluence and NotebookLM, and close the Jira ticket.

Claude Code Sync hooks

Stage 5 is the constant. The senior engineer is the approval gate, not a step in every stage.

The economics

Cost-aware by design: scale leverage, not the bill

AI-assisted engineering has a hidden variable cost: the metered tokens spent letting agents read context and iterate all day. I treat that as an engineering-economics problem, not an afterthought. Reasoning-heavy roles run on metered APIs where the quality justifies the spend; high-volume implementation runs on flat-rate tooling; and sourcing is a deliberate build-versus-integrate decision rather than a default-to-vendor reflex.

How dispatch works

Fan out to isolated worktrees

A dispatch script hands each approved plan to a coding agent running in its own throw-away git worktree. Agents never touch main, run in parallel without colliding, and every run leaves its diff and log behind for the Stage 5 review. Nothing merges without a human verdict.

Why the cost curve stays flat

Reasoning on metered tokens, implementation on flat-rate tooling. The deep-thinking roles stay small and deliberate; the token-hungry code generation runs where volume does not meter.

More agents does not mean a bigger invoice. Scaling parallel implementation scales throughput, not per-token spend.

Build versus integrate, deliberately. I evaluated open-source models on Hugging Face against closed-model APIs on cost and data privacy, so AI sourcing is a decision, not a reflex.

Layer 4

The AI-readable context layer

The system does not re-explain itself every session. A machine-readable context layer lets engineers and AI tools navigate architecture, rules, and release knowledge without rescanning the codebase. Estimated onboarding: days to hours.

What is in the layer

context.md: project state, sprint goal, known risks, and team contacts as a machine-readable briefing.
Skill files: reusable prompt recipes for recurring tasks: bug triage, PR review, doc sync.
Hooks: file-save triggers that run validators and sync automatically.
Validators: structured output checks that reject malformed AI completions before they reach Stage 5.

Outcomes

Results

Bug-fix cycle

45 min

from ~4 hours

Docs in sync

57 pages

from manual, often stale

Doc update effort

~95%

reduction

Approval touchpoints

1 per fix

from multiple across the cycle

Adoption

From my workflow to the team's default

This is not a private productivity hack. I turned individual AI proficiency into a team capability: I defined the AI-assisted development playbook, the reusable prompts, workflows, guardrails, and agent-dispatch recipes, and onboarded engineers into it, so AI-augmented development became the default way the team builds rather than something only I do. Tool adoption across the engineering team followed, with the review pipeline acting as a force multiplier for code-review quality and delivery velocity, and less delivery risk concentrated in any single senior engineer.

What I did not do

Did not skip fundamentals. The secure form engine shipped first; AI capabilities are a separate, later layer in the roadmap.

Did not remove the human. Stage 5 is a hard approval gate, not a suggestion.

Did not over-automate. Each stage has a clear contract and fails explicitly rather than degrading silently.

What is next

Prompt-assisted schema generation. A schema UI builder where users describe a form in plain language and AI proposes a JSON schema for human review before activation.

Planned, not shipped. It sits on top of the stable non-AI platform, guardrail-first: strict output format, validation, and human review before any AI output reaches production data.

Back to homepage showcase The platform underneath: erp-web-form The same philosophy at home: Atlas Agentic OS