AutoGineer
Generated banner for Notion Spec To Implementation
Generated logo for Notion Spec To Implementation

Notion Spec To Implementation

OpenAIOfficialCreated by Notion Labs, IncDistributed by OpenAI

  • Skill
  • Workflow
  • Business and productivity
  • MIT
  • No issues found
Download ZIP

From the author

Turn Notion specs into implementation plans, tasks, and progress tracking; use when implementing PRDs/feature specs and creating Notion plans + tasks from them.
— the description by Notion Labs, Inc

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a systematic approach to bridging the gap between high-level product requirements and execution. It guides users through locating and parsing Notion specifications, determining the appropriate planning depth, generating structured implementation plans, and creating linked tasks within a Notion database. The workflow emphasizes maintaining traceability between the original spec, the implementation plan, and individual tasks, while providing a framework for ongoing progress tracking and status updates.

What it does

  • Searches and retrieves product specifications from Notion.
  • Parses requirements, constraints, and acceptance criteria from raw documentation.
  • Generates structured implementation plans based on project complexity.
  • Creates actionable, sized tasks within a Notion database.
  • Establishes bidirectional links between specs, plans, and tasks.
  • Provides templates for progress tracking and milestone reporting.

When to use it

  • When you have a PRD or feature spec in Notion and need to start development.
  • When you need to break down a large project into manageable, tracked tasks.
  • When you want to ensure your implementation plan remains synchronized with the original spec.
  • When you need a consistent format for reporting progress and milestones.

Advantages

  • Reduces ambiguity by forcing a structured parsing of requirements.
  • Ensures project traceability by linking all artifacts.
  • Standardizes the creation of implementation plans and tasks.
  • Facilitates better progress visibility through defined tracking cadences.

Usage examples

“I have a new feature spec in Notion titled 'User Authentication Flow'. Can you turn this into an implementation plan and create the necessary tasks?”
The agent will search for the spec, parse the requirements, create a new implementation plan page, and generate linked tasks in your task database.
“We are starting a database migration. Use the 'Database Migration' spec to create a multi-phase plan.”
The agent will fetch the migration spec and generate a standard implementation plan with defined phases and dependencies.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/openai/notion-spec-to-implementation-zohc/download

  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip notion-spec-to-implementation.zip -d .agents/skills

Documentation by Notion Labs, Inc

Spec to Implementation

Convert a Notion spec into linked implementation plans, tasks, and ongoing status updates.

Quick start

  1. Locate the spec with Notion:notion-search, then fetch it with Notion:notion-fetch.

  2. Parse requirements and ambiguities using reference/spec-parsing.md.

  3. Create a plan page with Notion:notion-create-pages (pick a template: quick vs. full).

  4. Find the task database, confirm schema, then create tasks with Notion:notion-create-pages.

  5. Link spec ↔ plan ↔ tasks; keep status current with Notion:notion-update-page.

Workflow

0) If any MCP call fails because Notion MCP is not connected, pause and set it up:

  1. Add the Notion MCP:

    • codex mcp add notion --url https://mcp.notion.com/mcp

  2. Enable remote MCP client:

    • Set [features].rmcp_client = true in config.toml or run codex --enable rmcp_client

  3. Log in with OAuth:

    • codex mcp login notion

After successful login, the user will have to restart codex. You should finish your answer and tell them so when they try again they can continue with Step 1.

1) Locate and read the spec

  • Search first (Notion:notion-search); if multiple hits, ask the user which to use.

  • Fetch the page (Notion:notion-fetch) and scan for requirements, acceptance criteria, constraints, and priorities. See reference/spec-parsing.md for extraction patterns.

  • Capture gaps/assumptions in a clarifications block before proceeding.

2) Choose plan depth

  • Simple change → use reference/quick-implementation-plan.md.

  • Multi-phase feature/migration → use reference/standard-implementation-plan.md.

  • Create the plan via Notion:notion-create-pages, include: overview, linked spec, requirements summary, phases, dependencies/risks, and success criteria. Link back to the spec.

3) Create tasks

  • Find the task database (Notion:notion-search → Notion:notion-fetch to confirm the data source and required properties). Patterns in reference/task-creation.md.

  • Size tasks to 1–2 days. Use reference/task-creation-template.md for content (context, objective, acceptance criteria, dependencies, resources).

  • Set properties: title/action verb, status, priority, relations to spec + plan, due date/story points/assignee if provided.

  • Create pages with Notion:notion-create-pages using the database’s data_source_id.

4) Link artifacts

  • Plan links to spec; tasks link to both plan and spec.

  • Optionally update the spec with a short “Implementation” section pointing to the plan and tasks using Notion:notion-update-page.

5) Track progress

  • Use the cadence in reference/progress-tracking.md.

  • Post updates with reference/progress-update-template.md; close phases with reference/milestone-summary-template.md.

  • Keep checklists and status fields in plan/tasks in sync; note blockers and decisions.

References and examples

  • reference/ — parsing patterns, plan/task templates, progress cadence (e.g., spec-parsing.md, standard-implementation-plan.md, task-creation.md, progress-tracking.md).

  • examples/ — end-to-end walkthroughs (e.g., ui-component.md, api-feature.md, database-migration.md).

Files

evaluations/basic-spec-implementation.json

{
  "name": "Create Implementation Plan from Spec",
  "skills": ["spec-to-implementation"],
  "query": "Create an implementation plan for the User Authentication spec page",
  "expected_behavior": [
    "Step 1: Uses Notion:notion-search to find 'User Authentication spec' with keywords like 'User Authentication' or 'auth spec'",
    "Step 2: If not found or ambiguous, asks user for spec page URL/ID",
    "Step 3: Fetches spec page using Notion:notion-fetch with URL/ID from search results",
    "Step 4: Parses spec using patterns from reference/spec-parsing.md to extract requirements, acceptance criteria, constraints",
    "Step 5: Identifies functional requirements (user stories, features, workflows) and non-functional requirements (performance, security)",
    "Step 6: Creates implementation plan following structure from reference/templates.md",
    "Step 7: Includes sections: Overview, Linked Spec, Requirements Summary, Technical Approach, Implementation Phases",
    "Step 8: Breaks work into logical phases with Goal, Tasks checklist, Estimated effort per phase",
    "Step 9: Identifies dependencies and risks from spec content",
    "Step 10: Links plan back to original spec page using <mention-page url='...'>",
    "Step 11: Creates plan page using Notion:notion-create-pages with appropriate title (e.g., 'Implementation Plan: User Authentication')",
    "Step 12: Places plan appropriately (asks user or suggests under project/spec parent)"
  ],
  "success_criteria": [
    "Spec is found using Notion:notion-search before attempting to fetch (or user is asked for URL if not found)",
    "Spec is fetched using Notion:notion-fetch with correct URL/ID from search results",
    "Plan includes clear overview and spec link with mention-page tag",
    "Requirements are extracted from actual spec content (not generic) using spec-parsing patterns",
    "Work is broken into multiple phases (typically 3-5) following template structure",
    "Each phase has Goal, Tasks (as checkboxes), and Estimated effort",
    "Dependencies and risks sections are included with specific details from spec",
    "Plan follows Implementation Plan structure from reference/templates.md",
    "Success criteria or acceptance criteria from spec are referenced in plan",
    "Uses correct tool names and sequence: Notion:notion-search → Notion:notion-fetch → Notion:notion-create-pages"
  ]
}

Requirements and compatibility

Written for: OpenAI Codex

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Notion Labs, Inc
Publisher
OpenAI (Official)
Distributed by
OpenAI
Source
openai/skills · skills/.curated/notion-spec-to-implementation · commit 49f948f
Licence
MIT License (redistribution allowed)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Notion Labs, Inc or OpenAI.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download notion-spec-to-implementation.zip