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

Notion Spec To Implementation

JetBrainsOfficialCreated by OpenAIDistributed by JetBrains

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

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 OpenAI

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 the agent through locating and parsing Notion specifications, generating structured implementation plans, creating granular tasks within a database, and maintaining ongoing progress tracking. By standardizing the translation of PRDs into project management artifacts, it ensures consistency in documentation, task sizing, and status reporting.

What it does

  • Searches and retrieves product specifications from Notion.
  • Parses requirements, constraints, and acceptance criteria from raw specs.
  • Generates structured implementation plans based on project complexity.
  • Creates linked tasks in Notion databases with defined properties and templates.
  • Establishes bidirectional links between specs, plans, and individual tasks.
  • Provides templates for progress updates and milestone summaries.

When to use it

  • When you need to turn a new feature spec into a set of actionable development tasks.
  • When managing complex migrations or multi-phase feature rollouts.
  • When you need to ensure project documentation remains synchronized with task progress.
  • When you need to establish a consistent cadence for tracking project milestones.

Advantages

  • Reduces ambiguity by forcing a structured parsing of requirements.
  • Ensures all implementation artifacts are properly linked for traceability.
  • Standardizes task creation and sizing across different projects.
  • Maintains clear visibility into project status and blockers.

Usage examples

“Create an implementation plan and tasks for the 'User Auth' spec found in Notion.”
The agent searches for the spec, parses the requirements, creates a new implementation plan page, and populates the task database with linked items.
“Update the progress for the current database migration project.”
The agent reviews the linked tasks, updates status fields, and generates a milestone summary based on the progress tracking template.

Install

  1. Download the skill as a ZIP:

    https://mp-staging.autogineer.com/agent-skills/jetbrains/notion-spec-to-implementation/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 OpenAI

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.

  • 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

reference/progress-tracking.md

Progress Tracking

Update Frequency

Daily Updates

For active implementation work:

What to update:

  • Task status if changed

  • Add progress note to task

  • Update blockers

When:

  • End of work day

  • After completing significant work

  • When encountering blockers

Milestone Updates

For phase/milestone completion:

What to update:

  • Mark phase complete in plan

  • Add milestone summary

  • Update timeline if needed

  • Report to stakeholders

When:

  • Phase completion

  • Major deliverable ready

  • Sprint end

  • Release

Status Change Updates

For task state transitions:

What to update:

  • Task status property

  • Add transition note

  • Notify relevant people

When:

  • Start work (To Do → In Progress)

  • Ready for review (In Progress → In Review)

  • Complete (In Review → Done)

  • Block (Any → Blocked)

Progress Note Format

Daily Progress Note
## Progress: [Date]

### Completed
- [Specific accomplishment with details]
- [Specific accomplishment with details]

### In Progress
- [Current work item]
- Current status: [Percentage or description]

### Next Steps
1. [Next planned action]
2. [Next planned action]

### Blockers
- [Blocker description and who/what needed to unblock]
- Or: None

### Decisions Made
- [Any technical/product decisions]

### Notes
[Additional context, learnings, issues encountered]

Example:

## Progress: Oct 14, 2025

### Completed
- Implemented user authentication API endpoints (login, logout, refresh)
- Added JWT token generation and validation
- Wrote unit tests for auth service (95% coverage)

### In Progress
- Frontend login form integration
- Currently: Form submits but need to handle error states

### Next Steps
1. Complete error handling in login form
2. Add loading states
3. Implement "remember me" functionality

### Blockers
None

### Decisions Made
- Using HttpOnly cookies for refresh tokens (more secure than localStorage)
- Session timeout set to 24 hours based on security review

### Notes
- Found edge case with concurrent login attempts, added to backlog
- Performance of auth check is good (<10ms)
Milestone Summary
## Phase [N] Complete: [Date]

### Overview
[Brief description of what was accomplished in this phase]

### Completed Tasks
- <mention-page url="...">Task 1</mention-page> ✅
- <mention-page url="...">Task 2</mention-page> ✅
- <mention-page url="...">Task 3</mention-page> ✅

### Deliverables
- [Deliverable 1]: [Link/description]
- [Deliverable 2]: [Link/description]

### Key Accomplishments
- [Major achievement]
- [Major achievement]

### Metrics
- [Relevant metric]: [Value]
- [Relevant metric]: [Value]

### Challenges Overcome
- [Challenge and how it was solved]

### Learnings
**What went well**:
- [Success factor]

**What to improve**:
- [Area for improvement]

### Impact on Timeline
- On schedule / [X days ahead/behind]
- Reason: [If deviation, explain why]

### Next Phase
- **Starting**: [Next phase name]
- **Target start date**: [Date]
- **Focus**: [Main objectives]

Updating Implementation Plan

Progress Indicators

Update plan page regularly:

## Status Overview

**Overall Progress**: 45% complete

### Phase Status
- ✅ Phase 1: Foundation - Complete
- 🔄 Phase 2: Core Features - In Progress (60%)
- ⏳ Phase 3: Integration - Not Started

### Task Summary
- ✅ Completed: 12 tasks
- 🔄 In Progress: 5 tasks
- 🚧 Blocked: 1 task
- ⏳ Not Started: 8 tasks

**Last Updated**: [Date]
Task Checklist Updates

Mark completed tasks:

## Implementation Phases

### Phase 1: Foundation
- [x] <mention-page url="...">Database schema</mention-page>
- [x] <mention-page url="...">API scaffolding</mention-page>
- [x] <mention-page url="...">Auth setup</mention-page>

### Phase 2: Core Features
- [x] <mention-page url="...">User management</mention-page>
- [ ] <mention-page url="...">Dashboard</mention-page>
- [ ] <mention-page url="...">Reporting</mention-page>
Timeline Updates

Update milestone dates:

## Timeline

| Milestone | Original | Current | Status |
|-----------|----------|---------|--------|
| Phase 1 | Oct 15 | Oct 14 | ✅ Complete (1 day early) |
| Phase 2 | Oct 30 | Nov 2 | 🔄 In Progress (3 days delay) |
| Phase 3 | Nov 15 | Nov 18 | ⏳ Planned (adjusted) |
| Launch | Nov 20 | Nov 22 | ⏳ Planned (adjusted) |

**Timeline Status**: Slightly behind due to [reason]

Task Status Tracking

Status Definitions

To Do: Not started

  • Task is ready to begin

  • Dependencies met

  • Assigned (or available)

In Progress: Actively being worked

  • Work has started

  • Assigned to someone

  • Regular updates expected

Blocked: Cannot proceed

  • Dependency not met

  • External blocker

  • Waiting on decision/resource

In Review: Awaiting review

  • Work complete from implementer perspective

  • Needs code review, QA, or approval

  • Reviewers identified

Done: Complete

  • All acceptance criteria met

  • Reviewed and approved

  • Deployed/delivered

Updating Task Status

When updating:

1. Update Status property
2. Add progress note explaining change
3. Update related tasks if needed
4. Notify relevant people via comment

Example:
properties: { "Status": "In Progress" }

Content update:
## Progress: Oct 14, 2025
Started implementation. Set up basic structure and wrote initial tests.

Blocker Tracking

Recording Blockers

When encountering a blocker:

## Blockers

### [Date]: [Blocker Description]
**Status**: 🚧 Active
**Impact**: [What's blocked]
**Needed to unblock**: [Action/person/decision needed]
**Owner**: [Who's responsible for unblocking]
**Target resolution**: [Date or timeframe]
Resolving Blockers

When unblocked:

## Blockers

### [Date]: [Blocker Description]
**Status**: ✅ Resolved on [Date]
**Resolution**: [How it was resolved]
**Impact**: [Any timeline/scope impact]
Escalating Blockers

If blocker needs escalation:

1. Update blocker status in task
2. Add comment tagging stakeholder
3. Update plan with blocker impact
4. Propose mitigation if possible

Metrics Tracking

Velocity Tracking

Track completion rate:

## Velocity

### Week 1
- Tasks completed: 8
- Story points: 21
- Velocity: Strong

### Week 2
- Tasks completed: 6
- Story points: 18
- Velocity: Moderate (1 blocker)

### Week 3
- Tasks completed: 9
- Story points: 24
- Velocity: Strong (blocker resolved)
Quality Metrics

Track quality indicators:

## Quality Metrics

- Test coverage: 87%
- Code review approval rate: 95%
- Bug count: 3 (2 minor, 1 cosmetic)
- Performance: All targets met
- Security: No issues found
Progress Metrics

Quantitative progress:

## Progress Metrics

- Requirements implemented: 15/20 (75%)
- Acceptance criteria met: 42/56 (75%)
- Test cases passing: 128/135 (95%)
- Code complete: 80%
- Documentation: 60%

Stakeholder Communication

Weekly Status Report
## Weekly Status: [Week of Date]

### Summary
[One paragraph overview of progress and status]

### This Week's Accomplishments
- [Key accomplishment]
- [Key accomplishment]
- [Key accomplishment]

### Next Week's Plan
- [Planned work]
- [Planned work]

### Status
- On track / At risk / Behind schedule
- [If at risk or behind, explain and provide mitigation plan]

### Blockers & Needs
- [Active blocker or need for help]
- Or: None

### Risks
- [New or evolving risk]
- Or: None currently identified
Executive Summary

For leadership updates:

## Implementation Status: [Feature Name]

**Overall Status**: 🟢 On Track / 🟡 At Risk / 🔴 Behind

**Progress**: [X]% complete

**Key Updates**:
- [Most important update]
- [Most important update]

**Timeline**: [Status vs original plan]

**Risks**: [Top 1-2 risks]

**Next Milestone**: [Upcoming milestone and date]

Automated Progress Tracking

Query-Based Status

Generate status from task database:

Query task database:
SELECT 
  "Status",
  COUNT(*) as count
FROM "collection://tasks-uuid"
WHERE "Related Tasks" CONTAINS 'plan-page-id'
GROUP BY "Status"

Generate summary:
- To Do: 8
- In Progress: 5
- Blocked: 1
- In Review: 2
- Done: 12

Overall: 44% complete (12/28 tasks)
Timeline Calculation

Calculate projected completion:

Average velocity: 6 tasks/week
Remaining tasks: 14
Projected completion: 2.3 weeks from now

Compares to target: [On schedule/Behind/Ahead]

Best Practices

  1. Update regularly: Don't let updates pile up

  2. Be specific: "Completed login" vs "Made progress"

  3. Quantify progress: Use percentages, counts, metrics

  4. Note blockers immediately: Don't wait to report blockers

  5. Link to work: Reference PRs, deployments, demos

  6. Track decisions: Document why, not just what

  7. Be honest: Report actual status, not optimistic status

  8. Update in one place: Keep implementation plan as source of truth

Requirements and compatibility

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
OpenAI
Publisher
JetBrains (Official)
Distributed by
JetBrains
Source
JetBrains/skills · notion-spec-to-implementation · commit 3f53782
Licence
MIT License (redistribution allowed)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by OpenAI or JetBrains.

Download ZIP

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