Skip to content
Back to case studies
NDA-safeGenAI / AI2026

AI-Driven Development

Ad-hoc AI coding → governed Claude Code delivery loop with standards, app KBs, skills, commands, Jira context, and PR review gates.

Role
Forward Deployed AWS & GenAI Platform Architect
Context
Enterprise / Standards
Duration
6+ weeks foundation and rollout design
Team
Architecture working group + pilot engineering team

Tech stack

  • Claude Code
  • Anthropic
  • Atlassian MCP
  • Jira
  • Confluence
  • Bitbucket
  • Markdown
  • Obsidian
  • Playwright
  • Azure DevOps
  • AWS Secrets Manager
  • Java
  • React
  • TypeScript
  • Python
Executive summary

Business problem and production context.

Business problem

ASTM wanted to move from AI as a small coding assistant toward AI-assisted delivery on real enterprise tickets. The risk was not model quality alone. Without repo standards, app memory, ticket structure, guardrails, and rollout sequencing, AI could generate code that compiles but does not fit the system, misses team conventions, or creates governance gaps.

Architecture decision

Designed the AI-driven delivery substrate: developer-facing standards, working-group program library, per-team application knowledge base, Claude Code slash commands, skill architecture, Jira/Confluence context flow, session logs, PR-review gates, and phased rollout from proof of concept to multi-team adoption. The approach kept human design and review as the quality gate while giving AI enough structured context to write useful implementation code and tests.

awsASTM AI-driven delivery programRequestResponseWORK INTAKEAI DELIVERY LOOPMEMORY + GOVERNANCE123456789JIRJiraticket + ACCONConfluencedesign contextCLAClaude Codedev-start loopCLACLAUDE.mdrepo rulesSKISkillsstandards + KBCOMCommandsdev + KB flowsLOCLocal testsunit + e2eBITBitbucketsource + PRAPPApp KBpersistent memorySESSession logaudit trailCROSS-CUTTING: Developer review gate · Intent confirmation · KB diff approval · Org coding standards
What Rahul owned

The useful proof is the decision surface, not only the result number.

These are the parts of the work that show production judgment: ownership, constraints, rollback, cost, and observability.

Owned scope

  • AI-driven delivery system architecture connecting tickets, design context, repo instructions, app memory, implementation, tests, pull requests, and KB/session-log updates
  • Developer-facing standards and command/skill patterns so Claude Code worked from ASTM-specific rules instead of generic coding advice
  • Rollout model from proof of concept to pilot, AI-authored test maturation, and multi-team adoption with developer review as the quality gate

Evidence artifacts

System architecture diagramSeven-process diagram setFour-step rollout planCommand and skill architectureApplication KB lifecycleStandards and onboarding vault
Constraints

What would fail first?

Every project has constraints. The useful work is naming them early enough that rollback, cost, and ownership are designed before an incident.

Enterprise fit

AI output had to fit existing teams, Jira, Confluence, Bitbucket, Azure DevOps, and review practices instead of requiring a new delivery platform.

Context reliability

Claude Code needed durable app memory, coding standards, ticket context, and design boundaries before touching implementation code.

Governance

The workflow had to preserve human approval, auditability, secret hygiene, and controlled rollout across multiple product teams.

Decision table

Trade-offs accepted on purpose.

Option
Decision
Reason
Single command vs many commands
Chose one dev-start loop so developers do not forget wrap-up steps or split context across disconnected sessions
Single command vs many commands: Chose one dev-start loop so developers do not forget wrap-up steps or split context across disconnected sessions.
Git KB vs Confluence-only KB
Kept git as source of truth for developer memory, with Confluence mirror for nontechnical readers
Git KB vs Confluence-only KB: Kept git as source of truth for developer memory, with Confluence mirror for nontechnical readers.
Manual command vs hidden hooks
Deferred hooks until the workflow was understood; hidden context loading is harder to debug during adoption
Manual command vs hidden hooks: Deferred hooks until the workflow was understood; hidden context loading is harder to debug during adoption.
AI author vs developer author
Shifted developers toward reviewer/approver while keeping design, judgment, and final approval human-led
AI author vs developer author: Shifted developers toward reviewer/approver while keeping design, judgment, and final approval human-led.
Risk table

Production risks and how they were controlled.

Risk
Mitigation
Owner
AI generated code that compiled but did not fit ASTM patterns
Made CLAUDE.md, app KBs, and organization coding standards first-class context loaded before implementation.
Architecture working group
Developers forgot wrap-up and KB drift accumulated
Designed one dev-start loop with an explicit wrap-up gate for KB diff and session-log updates.
Developer + AI workflow owner
Broad rollout before the loop was proven
Sequenced POC, pilot code loop, test-loop maturation, and multi-team rollout as separate gates.
Program leadership
Implementation approach

Small steps, visible changes, fewer surprises.

  1. 01

    Mapped the target operating model: developer invokes a single Claude Code command, AI reads ticket/design/app context, confirms intent, writes code/tests, runs checks, opens a PR, then proposes KB/session-log updates.

  2. 02

    Split the system into three source-of-truth layers: developer-facing vault for standards and onboarding, private program library for roadmap/ADRs/skills/commands, and team KB vault for app memory and session logs.

  3. 03

    Designed ASTM-wide coding standards for Java, React/TypeScript, Python, API, database, and cross-language conventions so AI output could be reviewed against enforceable rules.

  4. 04

    Built the application KB pattern: app overview, ownership boundaries, architecture, dependencies, constraints, test state, integrations, database notes, and recent change history.

  5. 05

    Defined skills and slash commands including coding standards loading, KB create/refresh, and the dev-start loop that reads Jira, Confluence, repo instructions, and app KB before implementation.

  6. 06

    Added governance and rollout sequencing: proof-of-concept, pilot code loop, KB buildout, AI-authored test maturation, and multi-team rollout with developer review as the final quality gate.

Result

Before and after.

AI usage model
Ad-hoc assistant
Governed delivery loop
Context source
Developer memory
CLAUDE.md + app KB + standards
Developer flow
Manual coding first
AI writes, developer reviews
Rollout path
Tool adoption unclear
POC → pilot → tests → multi-team

Rollback path

The rollout was reversible by phase: commands, skills, KB conventions, and team adoption could be paused or narrowed without changing Jira, Bitbucket, Confluence, Azure DevOps, or source-code ownership.

Cost considerations

No new infrastructure was required for the foundation. Cost decisions centered on Claude seats, bounded pilot scope, and avoiding hidden automation before the workflow proved useful.

Observability notes

Useful signals were PR quality, developer review friction, test pass/fail loop behavior, KB drift, session-log quality, and whether tickets carried enough structured context for AI implementation.

Related services

Forward Deployed AI EngineeringAWS Production Architecture ReviewGenAI / RAG Production Readiness

Have a similar production problem?

Send the current architecture, bill concern, deployment pain, or GenAI reliability issue. I will help you find the first real bottleneck.

Rahul LadumorBook a production reviewContact form