Skip to content
Back to search

goalcraft

SkillWorks with Claude CodeGitHub

Turn a rough draft, vague ambition, or messy task brief into a powerful Codex /goal objective for persistent, evidence-checked work. Use when the user asks to write, improve, format, sharpen, stress-test, or activate a Codex goal, thread goal, durable goal, or /goal prompt.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/grp06--goalcraft/badge.svg)](/listings/grp06--goalcraft)

HTML

<a href="/listings/grp06--goalcraft"><img src="/api/listings/grp06--goalcraft/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Clone the repo, then symlink it into your Codex skills directory:

git clone https://github.com/grp06/goalcraft.git
cd goalcraft
ln -s "$(pwd)" ~/.codex/skills/goalcraft

If your Codex setup uses a different skills directory, symlink the repo there instead. The skill is self-contained; it does not depend on any local project path.

Restart Codex, then invoke it with a rough brief. The brief doesn't need to be clean — that's the point:

> Use `$goalcraft` to turn this into a Codex `/goal`: > > I need to clean up the billing settings page in the web app. It's kind of half-done from a previous pass. The upgrade button works but the loading and error states are janky, and I think mobile is probably broken. Please make it match the rest of the settings UI, don't touch the Stripe webhook stuff or pricing logic unless something is obviously wrong, and don't do a huge refactor. It should have tests or at least whatever checks this repo normally uses. I want Codex to keep going until the page is actually usable and verified, but it should stop and ask me before changing public APIs, database schema, or anything payment-risky.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 186 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ---
  2. name: goalcraft
  3. description: >-
  4. Turn a rough draft, vague ambition, or messy task brief into a powerful Codex
  5. /goal objective for persistent, evidence-checked work. Use when the user asks
  6. to write, improve, format, sharpen, stress-test, or activate a Codex goal,
  7. thread goal, durable goal, or /goal prompt.
  8. ---
  9. # Goalcraft
  10. ## Core Contract
  11. Convert messy intent into a compact Codex `/goal` objective and activate it: a thread-scoped, user-controlled completion contract that persists until evidence says the work is complete or honestly blocked. A strong goal defines a closed loop: choose the next action, run it, score progress against an explicit evaluator or checklist, record the result, then continue or stop based on evidence. Treat the `/goal` as a launcher, not the full plan: the objective must be less than 4,000 characters, but if it fits under that hard limit, activate it instead of repeatedly shortening it. Goalcraft's default final result is an active goal, not merely a ready-to-paste draft. Only skip activation when the user explicitly asks for draft-only, review-only, planning-only, or says not to set/start the goal.
  12. For current Codex `/goal` mechanics, read [references/codex-goal-contract.md](references/codex-goal-contract.md) when the exact runtime behavior matters.
  13. ## Workflow
  14. 1. Decide whether a Goal is the right tool.
  15. - Use a Goal when the work has a durable objective, an evidence-based finish line, and a path that may require several turns of investigation or iteration.
  16. - Do not recommend a Goal for a one-line edit, simple explanation, short code review, or a request where the user wants one answer and then a stop.
  17. - If the finish line is vague, recommend a goal-sharpening pass before activation rather than drafting a broad objective like "make this better."
  18. 2. Identify the rough objective, workspace, and expected end state.
  19. - If the user supplied a draft, preserve their intent and tighten it.
  20. - If a repo or files are mentioned, inspect them before finalizing the goal.
  21. - If a critical success criterion is missing, ask the smallest necessary question; otherwise state assumptions.
  22. 3. Shape the goal around evidence, not effort. Use these six fields as the main drafting spine.
  23. - Outcome: what must be true at the end.
  24. - Verification surface: the tests, benchmark, report, artifact, logs, command output, source material, screenshots, or explicit confirmation that proves it.
  25. - Constraints: what must not regress while Codex works.
  26. - Boundaries: which files, directories, systems, tools, data, repositories, or resources Codex may use.
  27. - Iteration policy: how Codex should choose the next useful action after each attempt.
  28. - Blocked stop condition: when Codex should stop, what evidence to report, and what input would unlock progress.
  29. 4. Add supporting details only when they improve the contract.
  30. - Starting point: current context, repo, branch, artifact, issue, or known state.
  31. - Deliverables: concrete artifacts such as code paths, tests, PRs, reports, screenshots, or logs.
  32. - Approval boundaries: destructive actions, credentials, deploys, commits, messages, purchases, or other user-controlled decisions.
  33. - Checkpoint rhythm: how often to test, review, summarize progress, or pause.
  34. - Success metric: the observable result that proves completion.
  35. - Realistic environment: production-like preview, matching flags/config, representative data, authenticated browser session, real device, or other surface needed for evidence to mean what the goal says it means.
  36. - Progress surface: attempt ledger, current-state summary, draft PR, meaningful commit cadence, status artifact, update channel, or side-chat-readable status when the work may run for hours or days.
  37. 5. Design the feedback loop before drafting the final goal.
  38. - Identify the score: metric, checklist, test result, scorecard, artifact count, benchmark, manual-review packet, or other evidence that lets Codex decide whether progress improved, stalled, or completed.
  39. - For measurable goals, prefer a baseline, target, measurement method, and counter-metric or anti-gaming guardrail. For example, test pass-rate goals should not be achieved by reducing meaningful coverage.
  40. - Prefer a fast iteration evaluator plus a slower final gate. For example: cheap smoke test, subsampled eval, lint/typecheck, focused replay, or checklist during work; full suite, full replay, deploy check, visual review, or final report before done.
  41. - For environment-sensitive goals, name the closest realistic environment Codex may use. If it cannot access one, either make environment setup the preliminary goal or require proxy results to be labeled as such.
  42. - For visual goals, treat images as context unless image matching is explicitly the requirement. Define completion through feature checklist, design-system adherence, interaction behavior, accessibility, and visual-diff tooling when appropriate; do not allow shortcuts such as cropping or inlining the reference image to fake fidelity.
  43. - For multi-hour or multi-day goals, name or recommend durable tracking surfaces: a current plan/queue, experiment or attempt ledger, decision/rejection log, scratchpad or daily notes, and generated current-state summary when useful.
  44. - For long-running implementation goals, consider whether commits, a draft PR, deploy preview, status artifact, or update channel should be part of the control loop.
  45. - If the real goal cannot yet be measured, recommend a preliminary goal to create the checklist, evaluator, scorecard, or tracking files before starting the main continuation loop.
  46. - Treat tracking files as part of the control loop, not optional documentation. They should help the next agent choose the next action without rereading the full conversation.
  47. 6. For research or investigation goals, define the evidence standard before the work begins.
  48. - Ask for a claim inventory and evidence map when the task involves reproducing, auditing, or investigating uncertain source material.
  49. - Require the final artifact to separate confirmed findings, approximate reconstructions, support-only evidence, blocked claims, and remaining uncertainty.
  50. - If exact proof may be unavailable, say how proxy evidence should be labeled instead of letting a plausible artifact become an overclaimed conclusion.
  51. 7. Keep the objective usable by Codex.
  52. - Hard limit: the objective text after `/goal ` must be less than 4,000 characters.
  53. - Return the goal as soon as it fits under the hard limit.
  54. - Do not impose a lower working maximum such as 3,800 characters.
  55. - Treat only objectives of 4,000 characters or more as failed drafts.
  56. - The `/goal` should be the compact execution contract. Put rationale, examples, candidate lists, detailed scorecards, and nonessential context in companion notes outside the `/goal` payload.
  57. - Make every requirement auditable against files, commands, PR state, logs, screenshots, or explicit user confirmation.
  58. - Include score-loop and tracking-file detail in the `/goal` only when execution-critical; otherwise put detailed evaluator/checklist/memory structure in companion notes or a referenced repo document.
  59. - Include baseline, target, anti-gaming, realistic-environment, visual-completion, progress-surface, and cleanup-gate details in the `/goal` only when they are execution-critical; otherwise put them in companion notes.
  60. - Include exact commands only when they are already known from the repo or user.
  61. - Avoid hidden flags in slash text. `/goal --tokens 50K ...` is literal objective text in the TUI, not parsed syntax.
  62. - If a token budget is requested, present it separately from the objective text unless the target surface supports a separate budget field.
  63. - For complex or ambiguous work, recommend a planning/interview pass before setting the goal.
  64. - For very large work, include subagent/orchestration guidance only when the current Codex environment supports subagents and the work can be split into bounded, reviewable lanes.
  65. 8. Choose the output shape.
  66. - Always start with compact shape: Outcome, Context, Boundaries, Constraints, Verify, Iterate/done/stop.
  67. - Do not use the full checklist as output structure unless the user explicitly asks for a verbose draft outside `/goal`.
  68. - Do not force every planning concept into the `/goal`. Reason with the full checklist, then compress related items before output.
  69. - Merge deliverables into Boundaries.
  70. - Merge must-not-regress into Constraints.
  71. - Merge autonomy, checkpoint rhythm, and blocked stop conditions into Iterate/done/stop.
  72. - Keep examples and candidate lists outside the goal unless they are essential execution constraints.
  73. - Section soft budgets: Outcome 250, Context 650, Boundaries 900, Constraints 550, Verify 550, Iterate/done/stop 700 characters.
  74. 9. Validate length before activation.
  75. - Put only the ready-to-paste `/goal ...` command in a temporary file or pipe it to this skill's bundled validator: resolve `scripts/validate_goal_length.py` relative to the directory containing this `SKILL.md`, then run it with `--max-chars 3999`.
  76. - The validator belongs to Goalcraft, not to the user's working project. Do not search the user's repository for `scripts/validate_goal_length.py`.
  77. - The script strips a leading `/goal ` and counts the actual objective Codex validates.
  78. - Validate once. If it passes the hard limit, return it. Do not keep running validation or shortening the goal just to satisfy a lower target.
  79. - If it fails the hard limit, discard the draft and switch immediately to emergency shape: `/goal Complete [outcome] within [boundaries]. Preserve [constraints]. Verify with [checks/evidence]. Stop for [risks/blockers]. Done when [criteria].`
  80. - After emergency fallback, validate once against the hard limit using `--max-chars 3999`.
  81. - Do not run iterative "make it a little shorter" loops. More than one failed hard-limit validation means the draft shape failed, not the character counter.
  82. - Do not activate or return a final goal until the validator passes.
  83. - If the bundled script path is unavailable, use this deterministic fallback on the file containing the exact final `/goal ...` command:
  84. ```bash
  85. python3 - "$GOAL_FILE" <<'PY'
  86. import pathlib, sys
  87. text = pathlib.Path(sys.argv[1]).read_text(encoding="utf-8").strip()
  88. if text.startswith("```"):
  89. lines = text.splitlines()
  90. if lines and lines[0].startswith("```"):
  91. lines = lines[1:]
  92. if lines and lines[-1].startswith("```"):
  93. lines = lines[:-1]
  94. text = "\n".join(lines).strip()
  95. if text.startswith("/goal") and text[len("/goal"):].startswith((" ", "\n", "\t")):
  96. text = text[len("/goal"):].strip()
  97. count = len(text)
  98. print(f"objective_chars={count}")
  99. if count > 3999:
  100. raise SystemExit(1)
  101. PY
  102. ```
  103. 10. Activate the goal.
  104. - Default: after validation, activate the objective with the available goal surface (`create_goal`, `thread/goal/set`, or the current environment's equivalent).
  105. - If a current active goal already exists, do not silently replace it. Report the conflict and ask for confirmation unless the user has explicitly asked to replace the current goal.
  106. - If the goal tool supports a separate token budget and the user explicitly requested one, pass it as the tool's budget field rather than embedding budget syntax in the objective text.
  107. - If activation fails, report the exact failure and include the validated `/goal ...` text as the fallback artifact.
  108. 11. Decide output mode.
  109. - Default: activate the goal and return a short confirmation with assumptions, objective length, and any companion notes.
  110. - Draft-only exception: when the user explicitly asks not to activate, return a ready-to-paste `/goal ...` block plus a short assumptions list.
  111. - If the user asks for review, critique the draft first and include a revised version.
  112. - If the user explicitly asks to replace an existing goal, call the goal tool or app-server surface only after the objective is final.
  113. ## Output Format
  114. Return companion notes outside the goal when details should not spend objective characters. Use this shape by default after successful activation:
  115. ```markdown
  116. Activated goal:
  117. - Objective length: N characters
  118. - Assumptions: ...
  119. Notes outside the goal:
  120. - ...
  121. ```
  122. For draft-only requests, use this shape:
  123. ```markdown
  124. Assumptions:
  125. - ...
  126. Draft goal:
  127. /goal Outcome: ...
  128. Context: ...
  129. Boundaries: ...
  130. Constraints: ...
  131. Verify: ...
  132. Iterate/done/stop: ...
  133. Objective length: N characters
  134. Notes outside the goal:
  135. - ...
  136. ```
  137. Omit companion notes only for trivial goals. For nontrivial goals, prefer a short activated objective plus useful companion notes over a long objective. Do not put assumptions, rationale, candidate lists, or optional details inside the `/goal` unless they are execution-critical.
  138. ## Quality Bar
  139. - The goal should be operationally sharp enough that another agent can continue after compaction or resume.
  140. - The goal should make the next loop obvious: choose an action, run it, score it, record the result, and continue or stop.
  141. - For long-running goals, the goal or companion notes should identify the durable state files or generated views that preserve plan, attempts, decisions, and current status.
  142. - The objective should feel like a compact launcher. If it needs lots of nuance, put that nuance outside the goal or into a referenced file.
  143. - The goal should make premature completion hard: "done" must require evidence, not intent, elapsed time, budget exhaustion, proxy signals, or passing unrelated checks.
  144. - The goal should make fake progress hard: preserve meaningful coverage, realistic inputs, real interaction paths, and other counter-metrics that prevent Codex from satisfying the letter of the goal while missing the intent.
  145. - For research goals, the final output should preserve levels of epistemic support instead of flattening exact reproduction, approximate support, blocked claims, and uncertainty into one success claim.
  146. - For environment-sensitive goals, evidence should come from the closest realistic environment available; proxy evidence must be clearly labeled.
  147. - For visual goals, reference images should not become the only exit criterion unless the user explicitly asks for image matching; completion should be anchored to specs, design-system rules, interactions, accessibility, and visual-diff evidence when useful.
  148. - For long-running implementation goals, completion should include a cleanup/review gate: inspect failed attempts, remove abandoned scaffolding, run the relevant review/tests, and summarize final evidence plus remaining risks.
  149. - The goal should avoid over-prescribing implementation details unless those details are part of the actual requirement.
  150. - The goal should preserve user boundaries: planning-only, no edits, no deploys, no commits, or approval requirements must be explicit when present.
  151. - The final objective should pass this skill's bundled `scripts/validate_goal_length.py --max-chars 3999`. If it fits under the hard limit, activate it without further shortening. If the normal draft fails the hard limit, use the emergency compact shape and validate once against the hard 3,999-character maximum.
README.md · README · 53 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. ![Goalcraft infographic](assets/goalcraft-infographic.png)
  2. # Goalcraft
  3. Goalcraft turns a messy task description into a Codex `/goal` and activates it.
  4. When you use `/goal`, Codex works against a persistent, thread-scoped completion contract. A weak goal means the agent may claim "done" on something that isn't. Goalcraft writes compact launcher goals that define the outcome, verification surface, constraints, boundaries, iteration policy, and blocked stop condition, so the agent has to show real evidence before declaring success. For long-running work, it also pushes the goal toward a tight loop: choose an action, run it, score it with a fast evaluator or checklist, record the result, and continue or stop based on evidence.
  5. ## Install
  6. Clone the repo, then symlink it into your Codex skills directory:
  7. ```bash
  8. git clone https://github.com/grp06/goalcraft.git
  9. cd goalcraft
  10. ln -s "$(pwd)" ~/.codex/skills/goalcraft
  11. ```
  12. If your Codex setup uses a different skills directory, symlink the repo there instead. The skill is self-contained; it does not depend on any local project path.
  13. Restart Codex, then invoke it with a rough brief. The brief doesn't need to be clean — that's the point:
  14. > Use `$goalcraft` to turn this into a Codex `/goal`:
  15. >
  16. > I need to clean up the billing settings page in the web app. It's kind of half-done from a previous pass. The upgrade button works but the loading and error states are janky, and I think mobile is probably broken. Please make it match the rest of the settings UI, don't touch the Stripe webhook stuff or pricing logic unless something is obviously wrong, and don't do a huge refactor. It should have tests or at least whatever checks this repo normally uses. I want Codex to keep going until the page is actually usable and verified, but it should stop and ask me before changing public APIs, database schema, or anything payment-risky.
  17. ## What you get back
  18. An activated `/goal` that spells out:
  19. - **Outcome** — what must be true when the work is done
  20. - **Verification surface** — tests, benchmarks, logs, reports, screenshots, source material, or explicit confirmation that proves it
  21. - **Constraints** — what must not regress while Codex works
  22. - **Boundaries** — files, systems, tools, data, repositories, and user-controlled actions to stay within
  23. - **Iteration policy** — how Codex should choose the next useful action after each attempt
  24. - **Blocked stop condition** — when to stop, what evidence to report, and what input would unlock progress
  25. - **Durable state** — plan, experiment, decision, or notes files when the goal may run for hours or days
  26. The `/goal` itself is intentionally short. Goalcraft puts supporting rationale, examples, candidate lists, and detailed evaluator notes outside the goal unless they are execution-critical.
  27. By default, Goalcraft validates and activates the goal. Ask for a draft-only, review-only, or planning-only pass when you want text back without setting the active goal.
  28. Goalcraft will also say when a normal prompt is the better tool. One-line edits, simple explanations, short code reviews, or vague requests without an auditable finish line usually need either a normal Codex prompt or a goal-sharpening pass before activation.
  29. ## Length safety
  30. Codex caps `/goal` text at 4,000 characters. Goalcraft treats that as the hard limit and avoids repeatedly shortening drafts that already fit. If a normal draft exceeds the hard limit, Goalcraft switches to a compact fallback instead of shaving a few characters repeatedly. If you want to check a goal manually from this repo:
  31. ```bash
  32. python3 scripts/validate_goal_length.py --max-chars 3999 goal.txt
  33. ```
  34. That script is bundled with this Goalcraft repo. When the skill is used while working in another project, agents should resolve `scripts/validate_goal_length.py` relative to Goalcraft's own `SKILL.md`, not relative to the project being edited. If the skill runtime does not expose that path, Goalcraft's instructions include an inline Python fallback that works anywhere with Python 3.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.