n8n:spec-driven-development

Align code implementation with specifications in a specified directory.

Updated Jul 3, 2026
One-click install
npx skills add https://github.com/Rub-git/n8n-auto --skill n8n-spec-driven-development
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: n8n:spec-driven-development
Source: https://github.com/Rub-git/n8n-auto/tree/main/.agents/skills/spec-driven-development
Command: npx skills add https://github.com/Rub-git/n8n-auto --skill n8n-spec-driven-development

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill ensures that the implementation of features remains aligned with their corresponding specifications, reducing discrepancies and improving code quality.

Core Features & Use Cases

  • Spec Alignment: Ensures implementation matches the specifications in .agents/specs/.
  • Continuous Verification: Regularly checks for discrepancies between code and specifications.
  • Spec Updates: Facilitates updating specifications as implementation progresses.

Quick Start

To start working on a feature, first locate the spec in .agents/specs/. Read the spec to understand the scope and requirements. Begin implementation, ensuring that the code aligns with the spec. Update the spec as needed during implementation. After completing work, run a spec verification pass to ensure alignment.

Frequently Asked Questions about n8n:spec-driven-development

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I keep code implementation aligned with specifications during feature development?

To keep implementation aligned with specifications, you need a continuous verification process that monitors code changes against spec files. This ensures implementation matches requirements in your specified directory, reducing discrepancies and improving code quality.

What is spec-driven development and how does it guide the development process?

Spec-driven development is a process where specifications dictate implementation scope and requirements. It guides development by providing a reference point for consistent coding practices, ensuring features are built according to predefined specs in a specified directory.

How do I update specifications as implementation progresses?

You update specifications by modifying spec files as implementation progresses. This ensures that any changes in scope or requirements are reflected in the specification directory, maintaining alignment between the actual code and the documented specs.

Do I need a specific directory structure for specification management?

Yes, specification management requires a specified directory, such as `.agents/specs/`, where your spec files are located. You need access to this codebase structure and the ability to execute commands within the directory to verify alignment.

What's the best way to verify code and spec alignment after completing a feature?

The best way to verify code and spec alignment is to run a spec verification pass after completing your work. This continuous verification checks for discrepancies between the implementation and the specifications in your directory.

Why does my feature implementation have discrepancies with the original specifications?

Discrepancies occur when implementation drifts from specs without updates. Regularly checking for alignment and updating specifications as implementation progresses prevents these mismatches and ensures consistent development practices.