langchain-bmad

Use langchain-bmad when the job is combining BMAD phase discipline with the LangChain ecosystem, not when the user only needs a single framework skill in isolation. Keep the entrypoint focused on routing: choose the BMAD phase, choose the framework lane, then load the narrowest downstream skill or support file that fits.

When to use this skill

• Start a new agent project and choose between LangChain, LangGraph, and Deep Agents inside a BMAD workflow
• Route a BMAD artifact or phase gate for a LangChain ecosystem project
• Decide which framework-specific skill should be loaded next after a BMAD planning or architecture step
• Install the BMAD and LangChain skill sets together for one project
• Keep framework choice, persistence, and HITL decisions aligned with BMAD phase boundaries

Use a narrower skill instead when:

• the user already knows the exact framework problem and does not need BMAD phase routing: use langgraph-fundamentals, deep-agents-core, or the specific LangChain skill directly
• the user mainly needs BMAD phase routing without framework-specific guidance: use bmad
• the user is still shaping the idea before structured delivery: use bmad-idea

Instructions

Step 1: Classify both dimensions before naming commands

Identify:

• BMAD lane: bootstrap, phase-status, artifact-routing, phase-gate, or implementation handoff
• Framework lane: LangChain, LangGraph, Deep Agents, or framework-selection

Do not dump every BMAD phase and every LangChain skill in one response before these two lanes are clear.

Step 2: Choose the BMAD phase and the next framework decision together

Use references/phase-map.md to map the current BMAD phase to the narrowest next skill:

• Analysis: framework-selection
• Planning: langchain-dependencies
• Solutioning:
  • LangChain -> langchain-fundamentals
  • LangGraph -> langgraph-fundamentals plus langgraph-persistence
  • Deep Agents -> deep-agents-core
• Implementation:
  • LangChain -> langchain-middleware, optional langchain-rag
  • LangGraph -> langgraph-human-in-the-loop, langgraph-persistence
  • Deep Agents -> deep-agents-memory, deep-agents-orchestration

If the user has not chosen a framework yet, stop at framework-selection instead of pretending all three lanes should run.

Step 3: Load only the support file that matches the current gap

Use progressive disclosure:

• references/phase-map.md for the BMAD-phase to framework-skill routing table
• references/setup-and-handoff.md for install commands, package bundles, and handoff rules between BMAD and framework skills

Keep the main skill compact instead of leaving the entire phase map, setup guide, and implementation catalog inline.

Step 4: Preserve BMAD gates while delegating framework detail

Use bmad to keep artifact progression and review gates honest:

• use BMAD to decide which artifact is next
• use the framework skill to shape the technical content of that artifact
• use plannotator or the existing BMAD review gate before advancing major phase documents

Do not let framework implementation detail bypass the BMAD artifact gate.

Step 5: Verify that the route is specific and minimal

Before claiming success, prove that:

• the chosen BMAD phase matches the user's immediate job
• the chosen framework lane is explicit
• the response names the next skill or command, not the whole catalog
• the answer makes clear when to return to bmad versus stay inside a framework-specific skill

Examples

Example 1: Choose a framework before architecture

Input:

We want to use BMAD for an AI support agent, but we still need to decide between LangGraph and Deep Agents.

Expected shape:

• treats this as BMAD analysis or planning plus framework selection
• routes first to framework-selection
• avoids listing implementation-only skills before the framework decision is made

Example 2: Route a LangGraph architecture phase

Input:

Our PRD is approved. We need the next BMAD step for a LangGraph workflow with durable execution.

Expected shape:

• recognizes this as BMAD solutioning after a reviewed PRD
• routes to architecture work plus langgraph-fundamentals and langgraph-persistence
• keeps BMAD phase gating explicit

Example 3: Keep ideation out of the framework bridge

Input:

Brainstorm three agent product ideas before we choose any framework.

Expected shape:

• routes to bmad-idea
• avoids forcing a LangChain ecosystem decision too early
• returns to langchain-bmad only after the idea is ready for structured delivery

Example 4: Hand off implementation to the right framework skill

Input:

The architecture is done. We need HITL approval and persistence in our LangGraph app.

Expected shape:

• treats this as implementation handoff, not fresh BMAD setup
• routes to langgraph-human-in-the-loop and langgraph-persistence
• keeps bmad as the artifact-tracking layer rather than repeating all BMAD phase detail

Best practices

1. Decide the BMAD lane and framework lane before suggesting commands.
2. Stop at framework-selection when the stack choice is still open.
3. Keep BMAD responsible for artifact progression and review gates.
4. Push phase maps and install detail into references instead of bloating the entrypoint.
5. Prefer one narrow framework skill over a full LangChain catalog dump.
6. Add evals before considering a mutation loop for this bridge skill.
7. Return to bmad when the question becomes artifact progression rather than framework implementation.

References

• references/phase-map.md
• references/setup-and-handoff.md
• LangChain Skills launch
• Deep Agents skills docs
• BMAD Method docs
• Creative Intelligence docs