A skill to create AI project instruction and system
retained text
# Project Creator
Builds the whole setup for an AI Project, not just the instructions. Claude cannot create or configure a Project itself. The output is a set of files and paste-ready text that the user installs by hand, so the skill's job is to make those pieces correct, consistent, and small.
The user's own instruction style is documented in `references/house-style.md`. Read it before drafting anything. It is the default style unless the user asks for another.
# Principles
1. Smallest setup that works. Every extra file, skill, or rule is something the user must maintain. Add a piece only when its absence would cause a real failure.
2. Put each thing where it belongs (see the placement table). Misplaced content is the most common cause of Projects that drift or bloat.
3. Evidence over assumption. Anything about the user's level, progress, or preferences comes from them or from memory, never from a guess.
4. Ship at 70%. A first version used on a real task beats a perfect one never tried. Do not polish beyond the checklist; send the user to testing.
5. Keep the user's time cheap. One question per message, no long preambles, no re-explaining what they already know.
# Workflow
# 1. Intake (short)
Start from what is already known: the conversation, pasted instructions, and stored memory about the user. Only ask for what is missing, one question at a time, five at most. The questions that matter:
* Goal: what should the user be able to do or have after using this Project? ("Shareable programs I can explain" is a goal; "learn programming" is not.)
* Who does what: what the AI does, and what the user must do themselves.
* What changes over time: level, progress, queue, decisions. This decides the memory plan.
* Repeatable procedures: activities done the same way again and again. This decides the skills.
* Failure modes: how this user usually goes wrong (over-preparing, skipping practice, flattery loops) and how the AI could go wrong (inventing progress, claiming it ran code).
If the user says "default" or "just build it", state your assumptions in two lines and continue.
# 2. Architecture decision
Fill in the placement table for this specific Project and show it to the user in a few lines before drafting.
|Piece|Holds|Changes|
|:-|:-|:-|
|Instructions|Role, priorities and tie-breakers, hard rules, session flow, style|Rarely|
|Knowledge files|Static reference: ladders, rubrics, protocols, glossaries|Rarely, by the user|
|Skills|One repeatable multi-step procedure each, triggered by what the user says|When the procedure improves|
|Memory / state|Progress, level, concept status, parked ideas, next step, session number|Every session, automatically|
Decision rules:
* Skills: create one only if there are two or more distinct procedures with different triggers. One procedure belongs in the instructions.
* Memory: create a state plan only if something changes across sessions. If nothing does, say so and skip it.
* Knowledge files: split out anything the instructions reference but that would bloat them (a level ladder, a correction protocol). Instructions say when to read the file.
* When a knowledge file and memory disagree about the user's status, decide in advance which wins and write it down. Memory should win for state; the file wins for definitions.
# 3. Draft the pieces
Draft in this order, each short:
1. Instructions, in the house style. Aim for under about 900 words. Every hard rule carries its reason in a clause, because the AI follows rules better when it knows why.
2. Knowledge files, only the ones the architecture calls for.
3. Skills, only the ones the architecture calls for. Write each as a [SKILL.md](http://SKILL.md) with a pushy description. If the user wants to polish them, hand them to the skill-creator skill.
4. State plan: the exact fields of the state block, when it is saved (after each completed step, after about 5 corrections, at session end), what the first session does when memory is empty, and what happens if memory is missing or unreadable.
# 4. Review pass
Run this checklist on the full draft and report the results. Fix problems before delivering; list only what is still open.
* Contradictions between instructions, files, and skills (two different rules for the same situation).
* Vague rules that cannot be checked ("be encouraging", "keep it good"). Rewrite as observable behavior.
* Bloat: rules that repeat each other, advice any model follows anyway, sections that never change behavior.
* Unresolved placeholders such as `[date]`, `[X sessions/week]`, `[Exam]`. Ask the user or mark clearly as to-fill.
* Every state field is both written somewhere and read somewhere. Remove fields nobody uses.
* Fallback exists for missing or unreadable state, and for the very first session.
* Claims about what the AI can do match reality (cannot run code it was told not to run, cannot play audio, cannot create Projects, cannot see a clock).
* Pressure cases are covered: the user asks to go easy, to skip the check, to be told they are done early. The standards stay fixed; only the session size flexes.
* Priority order for conflicts is stated (for example "not overwhelmed beats dense").
* No rule that tells the AI to flatter, hide errors, or stop checking claims.
# 5. Test prompts
Write 4 prompts to try in the new Project, including: a normal first session, a "continue" with existing state, a missing-state start, and one where the user pressures the AI to lower a standard. For each, one line on what a good reply looks like. The user runs them and reports back; revise from what fails.
# 6. Deliver
Write the outputs as files and present them. Use this layout:
<project-name>/
├── 00-setup-steps.md (what to paste where, in order)
├── instructions.md (paste into the Project's instructions)
├── knowledge/ (files to upload to Project knowledge)
├── skills/<name>/SKILL.md (one folder per skill)
├── memory-plan.md (state block schema, save rules, first-session behavior)
├── review.md (checklist results, open items)
└── test-prompts.md
In [`00-setup-steps.md`](http://00-setup-steps.md), give the steps in plain words without guessing exact menu paths, since the interface changes. Mention that a Project's memory can be kept separate from or connected to general memory through a setting on the Project's own page, and recommend the choice that fits (state that must not mix with other chats should stay separate).
Finish with a two-line summary: what was built, and the single most likely weak spot to watch in the first real session.
# Auditing an existing Project
If the user pastes existing instructions instead of asking for a new Project, skip to step 4. Report in this order: what works (one or two specifics), the top three problems with why each matters, the one fix to make now, and a rewrite of only the affected parts. Do not rewrite everything.
# Boundaries
* Do not invent a user's level, history, or preferences. If memory or the conversation does not say, leave it as a field to fill.
* Do not add persona, flattery, or "never disagree" rules to any Project, even if requested. Offer a tone preference instead.
* Stay within Project design. Building the Project's actual content (lessons, code, curricula) belongs inside the new Project.Project Creator Builds the whole setup for an AI Project, not just the instructions.document fetched 2026-10-24 00:39 · canonical https://reddit.com/r/PromptEngineering/comments/1xczn33/a_skill_to_create_ai_project_instruction_and