Gulajava Ministudio

Posted on Jun 6

From Idea to Code with SDLC 2.0: Orchestrating Custom AI Agents in the GitHub Spec Kit Methodology

#ai #webdev #programming #productivity

From Idea to Code with SDLC 2.0: Orchestrating Custom AI Agents in the GitHub Spec Kit Methodology

Welcome to the era of "Vibe Coding." We are no longer just writing code; we are directing an orchestra. As AI coding assistants evolve, treating them like simple autocomplete tools is a massive waste of potential.

If you want to build complex, scalable applications without getting lost in AI hallucinations, you need a system. Enter SDLC 2.0 (Software Development Life Cycle 2.0) combined with the GitHub Spec Kit methodology.

Instead of relying on a single, confused AI prompt to do everything, we break down the software development process into specialized "Custom Agents." Each agent has a distinct persona, strict boundaries, and specific deliverables.

🌟 Quick Link: All the agent templates, .agent.md, and .skill.md files discussed in this article are open-source! You can find and clone them from the Awesome Copilot ID Repository on GitHub.

Here is how you can orchestrate your own virtual engineering team.

The Anatomy of a Custom Agent
In the GitHub Spec Kit methodology, an agent is defined by two separate Markdown files:

The Brain (.agent.md): Defines the persona, core directives, and behavioral constraints (e.g., "You are a Senior Architect. Do not write code, only write specifications.").

The Standard Operating Procedure (.skill.md): Defines the step-by-step workflow and mandatory document templates the agent must use to output its findings.

By separating the "Brain" and the "SOP," we ensure our AI agents act deterministically and professionally. Let's meet the team and walk through the SDLC 2.0 pipeline.

Phase 0: Discovery & Onboarding
Meet the @BrainstormingExplorerAnalyst

What if you aren't starting from scratch, but jumping into a legacy codebase with zero documentation? This is where Phase 0 begins.

Instead of asking AI to blindly add features, we deploy the @BrainstormingExplorerAnalyst. Operating with the persona of a Senior Staff Engineer, this agent operates in strict read-only mode.

Its superpower: It maps out entry points, traces data flows, and critiques the current architecture. It will actively point out if your business logic is leaking into your UI layer (violating Clean Architecture). Once the brainstorming session is done, it proactively generates a "Project Discovery Draft"—a raw summary of tech debts and boundaries to be handed over to the Product Manager.

Phase 1: Requirement Definition
Meet the @ProductManagerPRD

With the Discovery Draft in hand (or a raw idea in your head), the Product Manager agent takes over. Its sole purpose is to translate human ideas into a structured Product Requirements Document (PRD). It defines the user stories, business goals, and metrics of success, ensuring the "Why" is firmly established before a single line of code is written.

Phase 2: Interrogation & Edge Cases
*Meet the @ClarificationAnalyst (Equipped with the "Grill Me" Protocol)
*
This is the gatekeeper. The Clarification Analyst reads the PRD and attempts to break it. To prevent the AI from overwhelming you with a wall of text, this agent is equipped with the revolutionary "Grill Me" Protocol, which enforces two strict rules:

One Question Only: It must ask questions sequentially. No machine-gun questioning.

Do the Heavy Lifting: It is forbidden from asking lazy, open-ended questions like "How should we handle errors?" Instead, it must propose concrete trade-offs: "For timeout errors, should we (A) Silently retry 3 times, or (B) Show a 'Try Again' UI? I recommend A. Do you agree?"

Phase 3: Architecture & Data Contracts
Meet the @SpecificationArchitect

Once the PRD is airtight, the Specification Architect takes over to define the "How." It investigates your existing codebase to maintain consistency.

Adaptive File Strategy: If the feature is small, it appends the spec to an existing file. If it's a massive system, it breaks it down into multiple modular files (e.g., spec-auth.md, spec-db.md) tied together by a spec-index.md.

Architecture Decision Records (ADRs): Any hard-to-reverse technical decisions made during this phase are permanently documented.

Phase 4: Roadmap Generation
Meet the @PlannerArchitect

You have the PRD and the Tech Specs. Now, the Planner Architect breaks down those massive markdown documents into atomic, executable step-by-step tasks. It creates a roadmap that the developer agents can execute sequentially without losing context.

Phase 5 & 6: Execution and Remediation
Meet the Dev, QA, and Bug Remediation Squad

God Mode Dev: This is the executor. Following the planner's roadmap, it writes the actual application code at lightning speed.

@ExpertCodeReviewer: Validates the code against the specifications. Did the Dev agent actually follow the schema defined in Phase 3?

@BugRemediationArchitect: If things break, this agent doesn't guess. It traces error logs, analyzes the stack trace, and applies surgical fixes without destroying the surrounding architecture.

🛠️ How to Integrate These Agents into Your IDE
You might be wondering, "How do I bring these markdown-based agents into my code editor?" It is surprisingly simple and works beautifully with modern AI workflows.

Method 1: GitHub Copilot (Workspace Instructions)
If you use VS Code with GitHub Copilot Chat, you can bind these agents to a specific project.

Create a .github folder in your project root.

Inside it, create copilot-instructions.md.

Paste the System Prompt of your desired agent (e.g., the Clarification Analyst's core directives and skill template) into this file.
Copilot will automatically read this file as its system guardrails, transforming its chat behavior to match the agent's persona.

Method 2: Google Antigravity (Standalone Setup)
If you prefer a distraction-free, asynchronous writing environment like Google Antigravity:

Create a .agents or docs/agents folder in your workspace.

Save your .agent.md and .skill.md files there.

Keep them in your sidebar as passive Standard Operating Procedures (SOPs). When drafting your prd.md, these agent files act as the context reference for your AI actions.

Method 3: OpenCode (Terminal Executor)
For the ultimate Vibe Coding setup, run your agents directly in the terminal while you write on your main screen.

Download your agent markdown files.

Load the agent into your terminal session using a system prompt flag. For example:
opencode --system-prompt .agents/BrainstormingExplorerAnalyst.md

Instruct it conversationally: "Please read the project files and initiate the Grill Me protocol on my latest PRD draft."

Conclusion & Resources
SDLC 2.0 is not just about writing code faster; it is about writing software smarter. By utilizing the GitHub Spec Kit methodology and assigning strict personas to Custom Agents, we eliminate AI hallucinations, maintain architectural integrity, and truly elevate our role from "Programmers" to "System Directors."

If you want to start orchestrating your own AI engineering team today, grab all the templates, agent files, and skill documentation directly from my repository:

👉 Explore the Awesome Copilot ID Repository

Have you tried orchestrating multiple AI agents in your local workspace? Let me know your workflow in the comments below!