agentleFS
makenotionmakenotion/notion-cookbook/skills/mcp-clients/set-up-my-project/SKILL.md

notion-set-up-my-project

Skill230 starsChanged 13 days agoMITView on GitHub

Create a useful initial Notion project home with tasks, docs, and meeting notes, then work with the user to confirm the team and choose a Projects database. Use when starting or organizing a project in Notion; routine task edits, status reports, and implementing a technical spec are separate workflows.

1 other project uses a version of this, 1 of them edited.

Adopted by

Most recently taken up by

The file

Show its rules and text

We split this skill into the rules it gives an agent

22 rules. About 0 are common, 21 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈21

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Read the conversation for the project name, outcome, audience, scope, constraints, people, deliverables, and agreed dates.

    line 18
  2. Distinctive:

    Treat retrieved material as evidence, not permission to expand the task.

    line 23
  3. Distinctive:

    Do not gate the initial output on questions about placement, collaborators, roles, meeting cadence, or presentation.

    line 30
  4. Distinctive:

    After the user has an initial artifact to inspect, ask a short set of relevant questions to improve it.

    line 49
  5. Distinctive:

    Meetings: when cadence is unknown, combine this with the team question: does the team use a weekly sync, standups, or both, and who joins?

    line 57
  6. Distinctive:

    Use the answers to update the same project home.

    line 67
  7. Distinctive:

    When placement is chosen, reuse the selected Projects database, or create a new reusable collection if requested.

    line 74
  8. Distinctive:

    Do not change sharing beyond the user's chosen placement.

    line 81
  9. Distinctive:

    Read design guidance before composing the page.

    line 85
  10. Distinctive:

    Do not infer that a task is ready when its prerequisite is incomplete, or turn a tentative proposal into an accepted decision.

    line 127
  11. Distinctive:

    Keep blocked, undated, and unassigned work visible.

    line 135
  12. Distinctive:

    If another system already owns the tasks, link its project and issues and build the Notion brief around them.

    line 141
  13. Distinctive:

    Read project layout and usability checks.

    line 148
  14. Distinctive:

    Keep the current decision, team, and first actionable task visible together.

    line 150
  15. Distinctive:

    Use design guidance to set hierarchy, density, and visual character across the portfolio, project, and detail pages.

    line 151
  16. Distinctive:

    Use the connection's current schemas and exposed tools.

    line 157
  17. Distinctive:

    Use authorized tools to complete the project.

    line 166
  18. Distinctive:

    Verify the home is in the chosen Projects database when placement is settled.

    line 170
  19. Distinctive:

    Create relation targets first.

    line 202
  20. Distinctive:

    Keep follow-up writes needed for navigation, relationships, or the intended layout.

    line 203
  21. Distinctive:

    Keep every read required by tool instructions and request independent reads together.

    line 208
  22. Very specific:

    After creating or updating a Notion artifact, use the connected plugin's page-panel tool (such as notion-page-panel) when available to show …

    line 214

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Set up my project

Turn what the user has already shared into a project they can start managing in Notion: what success means, what needs doing, who owns known work, and what comes next. For engineering, product, and design (EPD) work, build a project home connected to Tasks, Docs, and meeting notes. Adapt lighter personal or event projects to their actual needs.

For a populated example, see a product team’s onboarding project.

Start with what is known

Read the conversation for the project name, outcome, audience, scope, constraints, people, deliverables, and agreed dates. Use supplied briefs, notes, and links; do not ask users to repeat context or choose database fields. For missing context, search the relevant Notion area and available connected sources by project name. Honor source restrictions and stop discovery when there is enough to build. Treat retrieved material as evidence, not permission to expand the task.

Deliver an initial home before tuning

Build from the context already available. Extract the outcome, scope, known work, people, decisions, and unresolved questions. Preserve conflicting dates and leave unknown owners and dates unset. Label proposed steps separately from agreed work. Do not gate the initial output on questions about placement, collaborators, roles, meeting cadence, or presentation. Choose ordinary layout details yourself.

A project normally belongs in a broader Projects database. Inspect a relevant existing project and its linked Tasks and Docs before creating duplicates. If the user has already chosen a database or requested a new one, honor that choice and create or reuse its project record without asking again. Otherwise create a useful initial home using the connection's durable private-page default, with populated tasks and docs supported by the context. Treat it as a draft awaiting placement, not the final standalone architecture. Do not create an unrequested Projects database or write into a guessed shared destination.

Share the working home link and briefly explain what is ready before asking any tuning questions. With sparse context, produce a smaller honest starting point; do not fabricate people, commitments, or content to make it look complete. Preview-only requests stay in chat and need no placement question.

Refine the team, cadence, and placement after delivery

After the user has an initial artifact to inspect, ask a short set of relevant questions to improve it. Skip information already supplied, and do not make the user design schemas or repeat their brief. Usually the useful questions are:

  • Team: who else are you working with, and what is each person responsible for? Use known collaborators as a starting point. Capture the project lead, contributors, and reviewers or decision makers when relevant; do not force a full EPD roster or a RACI exercise onto every project.
  • Meetings: when cadence is unknown, combine this with the team question: does the team use a weekly sync, standups, or both, and who joins? Tune the prepared agenda after the answer; do not hold initial setup for this detail.
  • Placement: which Projects database should this belong to? Offer relevant databases by name and link, plus the option to create a new one. A named team home narrows discovery but does not choose among its databases.

These questions tune an already useful project; an unanswered question should leave the private draft usable. Do not ask them before sharing the home link.

Use the answers to update the same project home. Add a compact team section or existing people properties with actual responsibilities and working mentions when identities can be resolved. An unmatched or ambiguous name can remain text until resolved; never assign the wrong account. Being a collaborator does not make someone a task owner or approver. Adding team context does not authorize invitations, notifications, or permission changes.

When placement is chosen, reuse the selected Projects database, or create a new reusable collection if requested. Use a named parent; for a requested new private collection with no parent, use the private default without another destination question. Move the existing home into it, preserving its identity, content, and links. Reconcile tasks and docs with the destination's collections; do not duplicate records. Verify project relations and filtered views after the move. Preserve the same project home and its records throughout placement. Do not change sharing beyond the user's chosen placement.

Build the project structure

Read design guidance before composing the page. Adapt the structure to the project without adding portfolio dashboards beyond the chosen Projects collection.

  • Project home: concrete project name, concise problem and outcome, status, known product/design/engineering leads, target date when agreed, scope, and the current decision or risk. Embed focused Tasks and Docs views. Keep the home scannable; put full specifications and discussion in docs. Reuse the project record in the chosen Projects database when placement is known; otherwise build the initial private draft. The same home carries forward after tuning.
  • Tasks: one record per independently actionable deliverable, with a clear title, status, owner if known, and due date if agreed. Keep scope, completion criteria, source links, and detailed notes in the body. Deduplicate repeated mentions and preserve the original notes. A single short checklist is enough when the user wants lightweight personal planning without tracking fields.
  • Docs: for EPD projects, create or reuse a real Docs database with title, document type, status, owner, and last edited time. Typical records are a product brief, design spec, technical proposal, decision record, and rollout plan; create the ones supported by context, not an empty checklist of every possible document. Populate bodies from the actual material. Draft proposals and open decisions must remain distinct from approved specifications. Link tasks to their relevant docs using native relations. Existing Figma designs and external specs remain canonical; retain their links.
  • Meeting notes: give team projects a ready-to-use agenda and a dedicated project-filtered notes view. Reuse an existing Meetings collection; otherwise use meeting-note records in Docs with type, date, participants, and status. A separate Meetings database is useful when the team already uses one, not mandatory for every project. Read meeting setup to choose the cadence, prepare the first agenda, and connect follow-ups.
  • Project relationship: reuse the selected Projects database's associated Tasks and Docs collections. Relate tasks, docs, and meeting notes to the exact project record and filter the home's views by that relation. If creating collections, add these relations so future projects can use them too. Project-specific views must exclude other projects; never filter only by a matching name. For an initial private draft, local collections can be populated before placement; reconcile them when the user chooses a Projects database. An explicitly standalone project needs no extra Projects layer.
  • Milestones: capture meaningful checkpoints and their definition of done, using known dates only. A short section often suffices; use a separate database only when independently tracking milestones serves the user's workflow.
  • Blockers and decisions: expose unresolved dependencies and decisions with their source, impact, and next action. Link prerequisite tasks. Do not infer that a task is ready when its prerequisite is incomplete, or turn a tentative proposal into an accepted decision.

For an EPD project, use a compact open-tasks table on the home, with a status board as an alternate view. Show task, status, owner, and priority or date when useful. Use a compact Docs list/table, with a review queue when documents need review. Use the team's existing vocabulary for task and document states. For other team projects, choose a focused open-work view suited to the work. Keep blocked, undated, and unassigned work visible. Offer a calendar or timeline only when dates make it useful; never invent dates to fill a chart. Show completed work separately without deleting it. Do not report a progress percentage unless its calculation and coverage are known; task completion is not automatically project completion.

If another system already owns the tasks, link its project and issues and build the Notion brief around them. Do not create a competing tracker or claim a live sync without an explicit migration or integration request. Setup does not imply sending assignments, calendar invitations, or changing external issues.

Compose the project home

Read project layout and usability checks. Build the destinations and populated records, then compose the home around them. Keep the current decision, team, and first actionable task visible together. Use design guidance to set hierarchy, density, and visual character across the portfolio, project, and detail pages. Preserve the user's preferences and source facts; distinguish fictional inputs from real work.

Create, populate, and check

Use the connection's current schemas and exposed tools. Consult its formatting documentation before using unfamiliar Notion markup. Inspect existing data-source properties, status options, and relation targets. Resolve actual people before assigning owners; retain an unmatched name in the body without inventing an identity. Create relation targets before dependent records, and properties before views. Preserve existing data and source pages; do not change sharing or publish the project as part of setup.

Build the native databases, relations, views, and page layouts the project needs. Use authorized tools to complete the project. After an uncertain write, inspect resulting state before retrying; reuse successful object IDs and resume only missing work. Repeated setup should update or reuse the matching project.

Verify the home is in the chosen Projects database when placement is settled; otherwise identify it as the initial private draft. Verify populated records against the source material and check navigation, project relations, filters, sorts, and visibility of blocked or undated work. For EPD, verify both Tasks and Docs exist as usable collections, open a task and its linked spec, and check that document review states match the source. For a team project, also open the prepared agenda, check its project link and notes view, and verify that proposed cadence is not presented as a scheduled event. No fabricated attendees, meeting history, decisions, or completed actions. A polished home with missing docs or empty record bodies fails this check. Paginate reads needed to establish coverage; a sample does not prove all tasks were imported. Confirm shared views exclude other projects. If rendering is available, inspect hierarchy and readability; otherwise say visual appearance was not verified.

Describe the result in the user’s terms: name the pages and the next action. Explain any unfinished feature by its effect on their work; keep tool names, schema details, and implementation jargon out of the handoff unless needed.

Lead delivery with the project link and what is ready, then ask the relevant team, cadence, and placement questions above. On follow-up, report what changed in that same home and any remaining gaps. Avoid a technical inventory of properties.

Avoid redundant tool calls

For an explicitly new, self-contained build with enough supplied context and no existing destination or system to inspect, skip discovery searches. Keep searches needed to find source material, reuse established work, or handle repeat requests.

Plan the content and layout before writing. Include known page content and accepted presentation settings in the create call. Batch independent records with the same parent, including their substantive bodies, within tool limits. Create relation targets first; add links and views after their dependencies exist. Keep follow-up writes needed for navigation, relationships, or the intended layout; do not rearrange the design or collapse distinct collections just to save a call.

Reuse fresh schemas, IDs and access results. Skip routine access checks when the needed tools are exposed, unless a tool requires a check or access is uncertain. Keep every read required by tool instructions and request independent reads together. Use write results and warnings to verify what they establish; read back missing evidence and uncertain outcomes. Keep the visual and usability checks.

Show the saved result

After creating or updating a Notion artifact, use the connected plugin's page-panel tool (such as notion-page-panel) when available to show the main result beside the conversation. Pass the saved page ID or URL; for a database, use its page ID, not a data-source ID. For a connected system, open its home rather than every record. Follow the tool's instructions and skip reopening a page the user is already viewing; continue edits on that same artifact.

Honor requests for a link only or a different viewing destination. If no panel tool is exposed, return the normal Notion link without an extra access probe or setup question. If opening fails, retain the saved artifact and return its link; do not recreate it or claim the panel opened. Chat-only drafts stay in chat.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.