aidlc-studio 0.1.0

Applied AI Studio (AIDLC) — install a 23-agent Applied-AI delivery lifecycle pack into any project, for any AI IDE (Claude Code, Cursor, VS Code Copilot, Antigravity, Windsurf).

Applied AI Studio

A domain-agnostic Applied-AI agent system you install into your IDE. Drop in an executive problem statement — "our claims team is drowning in 40k calls a month" — and a roster of specialist agents drives it through the full AI Development Life Cycle: clarifying questions, a signed PRD, a solution verdict, a model + cloud strategy, a business case, evals, a go/no-go gate, a production plan, and a buildable spec — with a human in the loop at every decision that matters.

It runs natively in Claude Code, and via the AGENTS.md standard in Cursor, VS Code, and Antigravity. Connectors (Snowflake, Databricks, BigQuery, Bedrock…) plug in over MCP.

Not a chatbot. An org chart of specialist agents governed by a shared constitution and a single orchestrator — the way a Forward Deployed team actually delivers.

---

Why this exists

Most "AI initiatives" die the same three deaths: no one defined the problem, no one could prove it worked, or no one thought about production until it broke. This pack encodes the discipline that prevents all three — as agents you can run.

• Executives get a decision-grade brief, not a science project.
• PMs / BAs get the clarifying-question rigor and artifacts at every stage.
• Engineers get an unambiguous, testable AI Spec to build against.
• Everyone gets the human-in-the-loop gates and the audit trail regulators want.

The architecture (three layers)

 SETTINGS   registry/agents.json · registry/stages.json   ← the catalog an IDE installs
 GOVERNANCE CONSTITUTION.md · orchestrator · advisors      ← rules + routing + advice
 EXECUTION  12 pipeline agents + dev pipeline              ← each knows one job + artifact

The administrator = orchestrator + human. Advisors advise; the administrator decides; some decisions are reserved for the human (the HITL gates). Full picture in ARCHITECTURE.md.

The agents (23)

Group	Agents
Orchestrator	orchestrator — routes the problem, sequences stages, enforces gates
ADLC pipeline (12)	intake → process-map → assess → value-prop → architecture → dev-spec → data-science → eval → poc-gate → production → observability → brief
Advisors (7)	model-selector · cloud-gcp · cloud-aws · cloud-azure · cloud-onprem · connector-advisor · domain-advisor
Dev pipeline (3)	discovery → coder → code-reviewer (decoupled; consumes the AI Spec)

Each stage produces a real artifact (templates): Intake → a signed PRD, Assess → a solution verdict + model shortlist, POC gate → a GO / NO-GO, Brief → an end-to-end delivery brief. The artifact of stage N is the input contract of stage N+1.

The four cloud/technical agents (asked the same question)

cloud-gcp, cloud-aws, cloud-azure, and cloud-onprem each answer the same architecture question so you compare Vertex vs Bedrock vs Azure AI vs open-source on-prem like-for-like — then get one recommended path with the reason the other three lost. On-prem covers the open-weight stack (vLLM, Llama/Mistral/Qwen, Airflow, Milvus) for "must stay on-prem" mandates.

Install

With uv (recommended — works for every IDE):

uvx --from git+https://github.com/karthikbadri12/applied-ai-studio.git aidlc init --ide all
# per-IDE: --ide claude | cursor | copilot | antigravity
# then:    aidlc list · aidlc check

Full per-IDE guide: docs/INSTALL.md.

Claude Code (VS Code, JetBrains, terminal)

git clone <this-repo> && cd applied-ai-studio
claude   # the agents in .claude/agents/ are picked up automatically

Then: "Act as the orchestrator. Here's my problem statement: …"

Cursor / Antigravity / VS Code agents

• They read AGENTS.md and .cursor/rules/ automatically.
• Point the assistant at the repo and give it a problem statement; it adopts the orchestrator role and walks the pipeline.

Connectors (optional, any IDE)

• Copy the servers you need from connectors/mcp.example.json into your IDE's MCP config. Secrets go in a secret manager / gitignored .env.

A 3-minute demo

1. Give the orchestrator a one-line problem statement.
2. Watch intake run the clarifying-question loop and produce artifacts/01-prd.md, then stop at the sponsor sign-off gate.
3. Approve it. Watch assess (consulting model-selector + the four cloud agents + domain-advisor) produce a solution verdict and a model + cloud comparison.
4. Continue to the POC gate — a GO / CONDITIONAL / NO-GO backed by evals — and the final delivery brief with the AI Spec handoff.

Everything lands as files in artifacts/, so the demo shows its work.

Repo map

CONSTITUTION.md          the rules every agent obeys
ARCHITECTURE.md          the three-layer design + request flow
AGENTS.md                cross-IDE entry (Cursor / Antigravity / VS Code)
registry/                agents.json + stages.json  (the settings/catalog layer)
.claude/agents/          all 23 agent definitions (canonical source)
.cursor/rules/           Cursor glue
artifacts/templates/     the artifact each stage produces
connectors/              catalog + MCP config + per-connector guides
domains/                 15-industry registry + deep packs (domain-agnostic core)
pipelines/               the decoupled dev pipeline

What is AIDLC itself built with?

Deliberately, no agent framework. AIDLC is a framework-agnostic agent system:

• Agents-as-instructions: every agent is a versioned Markdown spec (charter, guardrails, skills, I/O contract) in .claude/agents/. The execution engine is whatever agentic runtime your IDE already has — Claude Code custom agents natively, or any AGENTS.md-standard assistant (Cursor, Copilot, Antigravity, Windsurf). No LangChain/LangGraph/ADK dependency to install, version, or secure.
• Methodology layer: Spec Kit (phase gates) + BMAD (persona pipeline) + Superpowers (composable skills) — see SKILLS.md.
• Governance layer: a Constitution + runtime harness (HARNESS.md) with hard/soft guardrails, five HITL gates, and an append-only audit ledger.
• Connectors: MCP (Model Context Protocol) — the one integration standard every major IDE speaks.
• Packaging: a small stdlib-only Python CLI (aidlc), built with hatchling, installed via uv/uvx — the same distribution pattern as GitHub's Spec Kit.

The solutions AIDLC designs do get a framework recommendation — chosen by the winning cloud advisor from registry/frameworks.json: GCP → Google ADK (deploy: Vertex AI Agent Engine) · AWS → Strands Agents + Bedrock AgentCore · Azure → Microsoft Agent Framework + AI Foundry Agent Service · on-prem → self-hosted LangGraph over vLLM/Ollama — each with named alternates, and "no framework" stated when a plain pipeline is the simpler answer.

Design principles

1. Ask before you build — no PRD from a one-liner; the intake question loop is mandatory.
2. Evidence over assertion — every number is labelled; nothing is fabricated.
3. Human-final — the reserved decisions stop the pipeline until a person approves.
4. One recommended path — with the alternatives and why they lost. No paralysis.
5. Artifacts are the interface — the whole initiative is legible from the files.

---

Built as a portable agent pack — one source of truth, four IDEs. Fork it, point it at your problem, and let the org chart run.