Advanced AI Programming: How to Effectively Harness OpenSpec, BMAD, and Skills

Why AI‑assisted coding stalls

Many developers enjoy the speed of AI‑generated code for simple tasks, but complex business logic often fails, leading to broken code, contradictory outputs, and the feeling of "AI forgetting". The author argues that after prolonged AI tool use, teams must evolve from Vibe Coding (intuition‑driven) to Vibe Engineering (engineered development).

The three pillars

BMAD (Breakthrough Method for Agile AI‑Driven Development) – the "Dao/Strategy" layer that defines the overall workflow (PM → Architect → Developer) and splits the process into planning, design, and execution phases.

OpenSpec – the "Fa/Tactic" layer that provides a structured markdown contract (Requirement + Scenario) to eliminate AI hallucinations and missed requirements.

Skills – the "Shu/Tool" layer that equips the AI with concrete abilities (web fetch, GitHub, terminal, etc.) to act on the specifications.

Efficient AI Development = BMAD (process) + OpenSpec (spec) + Skills (execution)

How to use BMAD

Reject "one‑shot" prompts : don’t ask the AI to write an entire e‑commerce site in one go.

Proper approach: use a PM Agent to break down requirements, an Architect Agent to design the solution, then a Developer Agent to implement.

Context isolation : separate chats for planning ( Chat 1 (Planning)) and coding ( Chat 2 (Coding)) to avoid token overload and loss of focus.

Never keep a single session for the whole project.

Tailor the process : for heavy tasks (new feature) run the full BMAD flow; for light tasks (bug fix, UI tweak) skip the PM stage and let the Developer Agent act directly.

How to use OpenSpec

Write core specs : for complex logic (payment, permissions, state flow) use markdown blocks ### Requirement and #### Scenario.

Reason: structured data focuses the LLM’s attention.

Use "@" references instead of pasting full specs into the chat. Store specs in .md files and reference them with @specs/login.md to keep prompts short and editable.

Let the AI draft specs : describe the idea verbally, then the Architect Agent generates the OpenSpec document; the human only reviews and refines.

Common misuse : over‑designing trivial UI changes; for simple tweaks, just converse verbally.

How to use Skills

Hard Skills (MCP) – connect the AI to the outside world.

Example: use Web Fetch to retrieve the latest Next.js docs.

Example: use GitHub to open an issue.

Soft Skills (Code as Skill) – turn repeatable patterns into reusable tools.

Create a prompt template or a script like generate‑crud.js and invoke it from the AI.

When a function (e.g., CRUD endpoint) is used often, encapsulate it as a Skill.

Skill composition – combine Terminal, File Read, and Web Search for debugging scenarios.

Integrated case study: building a user‑registration feature

Planning (BMAD) : the PM Agent receives the request "Create registration with email and Google login" and produces docs/PRD‑registration.md.

Design (OpenSpec) : the Architect Agent converts the PRD into specs/auth‑register.md containing a requirement "email format validation" and a scenario "email already taken".

Execution (Skills) : the Developer Agent uses zod for validation, writes Register.vue and useAuth.ts, and self‑checks against the spec.

Skills mounted: npm‑search, file‑write.

Verification : a QA Agent generates unit tests from the spec’s scenarios.

Key takeaways

BMAD gives a clear, stage‑by‑stage workflow that prevents AI "forgetting" and requirement chaos.

OpenSpec turns vague prompts into precise, verifiable contracts.

Skills act as the AI’s "plugins", extending its capability from pure code generation to full‑stack actions.

Common pitfalls and remedies

Over‑reliance on AI – keep human reasoning for core concepts.

Over‑specifying UI details – limit specs to core logic and edge cases.

Using a single chat for an entire project – open a new chat for each BMAD stage and reference prior outputs with @.

Loading too many Skills – only mount the ones needed for the current phase (e.g., file‑read, file‑write, terminal for development; add web‑search or npm‑search for debugging; enable github or docker for deployment).

Roadmap for mastery

Beginner (1‑2 weeks) : complete a small feature with BMAD, write 2‑3 OpenSpec docs, configure 1‑2 MCP Skills.

Intermediate (1‑2 months) : set up specs/ and prompts/ directories, maintain a .cursor rules file, tackle a medium‑complex feature.

Advanced (3+ months) : define team‑wide OpenSpec templates, build custom Soft Skills, explore applying the framework to micro‑services and multi‑team collaboration.

Next actions

Create a specs/ folder in your project.

Write an OpenSpec for a small upcoming feature.

Run the full BMAD flow for that feature, mounting only essential Skills.

Final thought

When you master BMAD, OpenSpec, and Skills, you become a "Software Commander" who orchestrates an AI army rather than merely typing code.