Rezics Propose
Productivityrezics-proposeRezics Propose is an Agent Skill for productivity published in the rezics/mason-gallery repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.
Propose a code-first plan — a single markdown file with context, durable constraints/decisions, and a task checklist. No spec files. Use when the user wants to turn an idea into actionable, implementable work.
How to use this skill
Bring this guide into your coding agent with a prompt tailored to the tool you use.
- Open your project in Codex.
- Copy and paste the prompt below.
- Review files and risks before approving any action.
Inspect the Agent Skill at https://github.com/rezics/mason-gallery/blob/HEAD/.claude/skills/rezics-propose/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/rezics-propose, but wait for my approval before writing files or running scripts.
Copying this prompt does not install or run the skill. Review third-party files before use.
Produce one executable plan at plan/proposal/<slug>.md. No spec files. No
validation CLI. A plan is a disposable scaffold: when its work
lands, its durable content has migrated into code/comments/tests and the plan can
be deleted (a human deletes it; you do not, unless told).
This project is code-first. A plan's job is to carry only what code cannot yet carry: the work to do, and the constraints/decisions the implementer must honor — the same constraints that will become comments and tests at apply time.
Steps
-
Get the request. If unclear, use AskUserQuestion to ask what they want to build or fix. Derive a kebab-case slug (e.g. "add poll voting" →
add-poll-voting). Do not proceed without understanding the goal. -
Ground in the codebase. Read the relevant domains before writing. Identify the files that will change and the existing patterns to match (
{domain}.api.ts/.service.ts/.mapper.ts/.types.ts; contracts in@rezics/contract; frontend API in@rezics/api). A plan written without reading the code is a guess. -
Write
plan/proposal/<slug>.mdusing the structure below. If a file with that slug exists, ask whether to continue it or pick a new slug. -
Summarize: slug, location, and the task count, then "ready to implement — ask me to start, or run
/rezics-apply." Implementation is ordinary coding against the tasks;/rezics-applycarries the routing rule that lands each durable item in code. There is still no apply CLI and no state machine.
Plan file structure
---
title: <Human title>
status: active # draft while shaping; active once ready to implement
created: <YYYY-MM-DD>
completed:
supersededBy:
tags: [<domain>, ...]
---
## Why
One or two paragraphs: the problem and the intended outcome. Not a spec — just
enough for an implementer (or future you) to know what this is for.
## Durable constraints & decisions
The non-obvious rules the implementation must honor — invariants, deliberate
non-restrictions, known tradeoffs, "do X not Y" boundaries. **These are the
items that must become code comments and tests at apply time.** Mark each with
its target home:
- `(comment)` an invariant/why that a type can't express
- `(test)` a behavior to lock with a test
- `(type)` a shape/value-set that the schema/types will carry — no prose needed long-term
## Tasks
- [ ] 1.1 <concrete, file-level step>
- [ ] 1.2 ...
Group with `## N. <phase>` headings when the work has phases.
These checkboxes are apply-time progress markers: `/rezics-apply` must mark
completed items as `- [x]` and leave unfinished or skipped items unchecked.
## Out of scope
What this plan deliberately does not do.
At apply time
The (comment)/(test)/(type) marks above are routing hints for /rezics-apply,
which owns the four-way routing rule (shape → types, behavior → test,
invariant/why → comment, history → commit message) and the comment-format
conventions. Propose only tags; apply routes — deciding a comment's exact
form needs the target site in view, which only happens at apply. When the work
lands, apply marks completed task checkboxes and sets status: done only if all
task-owned work is complete or explicitly no longer applicable (a human deletes
it later).
Guardrails
- Never create spec files or a parallel spec corpus. This workflow has no specs.
- Read before writing — ground the plan in real files and patterns.
- Keep the plan tight: tasks must be concrete and file-level; constraints must be the non-obvious ones, not a restatement of the types.
- Prefer reasonable decisions to keep momentum; only ask the user when a choice genuinely changes the work.
- Do not implement from this skill — proposing produces the plan; implementing is a separate step.