Define a measurable goal

Turns a fuzzy intention into one measurable goal with a validator, scope and stop condition, then registers it via get_goal and create_goal. Use before goal-backed or long-running agent work, when "done" needs a number or a check.

Vibe codingPack: OpenAI skills99 linesdefine-goal
Author
Source
openai/skills/skills/.curated/define-goal @ 49f948f
License
Apache-2.0

About this skill

What it does

The skill turns a vague intention into one objective an agent can be held to, then registers it with the agent's goal tool. By its rules a usable goal names the outcome that will be true, the artifact or system involved, how completion is verified, what is in and out of scope, and when to stop and ask instead of grinding on.

Where the domain allows, the goal gets numbers: an exact test command and pass condition, a latency threshold with measurement method and run count, the allowed blast radius, counts of verified cases. Activity goals such as "keep investigating" or "improve things" are rejected until they are sharpened. Sample goals show the bar: p95 under 250 ms across three benchmark runs is good, "make checkout faster" is weak.

If a missing detail would change the outcome, the agent asks one short question; otherwise it rewrites the goal itself. Before creating anything it calls get_goal: a matching active goal is reused, a conflicting one makes the agent ask. Only then does it call create_goal with a single objective string that includes the evidence. The skill writes no plans, logs or other files.

When to use it, and when not

Use it before goal-backed or long-running agent work, or whenever you want "done" settled before the agent starts.

For ordinary implementation requests the skill itself says to skip it.

How to run it

The install command below puts the folder in place: SKILL.md, the Codex metadata file and the licence. The skill calls get_goal and create_goal, tools of the host agent; where they do not exist, you get the goal text but nothing is registered. To call it:

  • Claude Code: /define-goal, or ask for the skill by name.
  • Codex: $define-goal.
  • Cursor: type / in the Agent chat and pick define-goal.

Example: /define-goal I want the flaky e2e suite fixed before the release.

OpenAI has marked openai/skills deprecated; our copy is pinned to a commit there, and as of November 2026 openai/plugins has no newer version of this skill.

How it differs from similar skills

Interview me pins down intent through a longer interview, one question per message, ending in a statement you confirm with an explicit yes. Spec-first kickoff and Spec-driven development go on to a written spec and a build plan. This skill stops at one measurable sentence and the goal tool call. Verification before completion works at the other end: it checks the evidence before the agent says "done".

Install

Run one command — it saves SKILL.md and the files it uses into your agent's skills folder. Claude Code and Codex pick up a new skill without a restart; if it does not show up, restart the agent.

Claude Code — macOS, Linux
curl -fsSL --create-dirs -o ~/.claude/skills/define-goal/SKILL.md https://anymodel.org/en/skills/openai/define-goal/SKILL.md -o ~/.claude/skills/define-goal/LICENSE.txt https://anymodel.org/en/skills/openai/define-goal/LICENSE.txt -o ~/.claude/skills/define-goal/agents/openai.yaml https://anymodel.org/en/skills/openai/define-goal/agents/openai.yaml
Codex, Cursor — macOS, Linux
curl -fsSL --create-dirs -o ~/.agents/skills/define-goal/SKILL.md https://anymodel.org/en/skills/openai/define-goal/SKILL.md -o ~/.agents/skills/define-goal/LICENSE.txt https://anymodel.org/en/skills/openai/define-goal/LICENSE.txt -o ~/.agents/skills/define-goal/agents/openai.yaml https://anymodel.org/en/skills/openai/define-goal/agents/openai.yaml
Claude Code — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml') { $p = Join-Path "$HOME\.claude\skills\define-goal" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/define-goal/$f" -UseBasicParsing -OutFile $p }
Codex, Cursor — Windows PowerShell
foreach ($f in 'SKILL.md','LICENSE.txt','agents/openai.yaml') { $p = Join-Path "$HOME\.agents\skills\define-goal" $f; New-Item -ItemType Directory -Force (Split-Path $p) | Out-Null; Invoke-WebRequest "https://anymodel.org/en/skills/openai/define-goal/$f" -UseBasicParsing -OutFile $p }

Any other agent: save the file into its skills folder, or give it the link to the file: https://anymodel.org/en/skills/openai/define-goal/SKILL.md

SKILL.md

Raw

Define Goal

Overview

Shape the user's intent into an objective an agent can pursue honestly. Prefer measurable outcomes, explicit evidence, and bounded scope over activity descriptions.

This skill covers goal definition and goal-tool creation only. Do not create intermediate planning artifacts, durable snapshots, ledgers, decision logs, or resume files from this skill.

Workflow

  1. Confirm that goal definition is actually needed.

    • Use this skill when the user asks for $define-goal, asks to create or set a goal, asks for the goal tool, or wants help turning an intention into a clear objective.
    • If the user only asks for ordinary implementation work, do the work directly instead of forcing goal creation.
  2. Restate the likely goal in concrete terms. A usable goal names:

    • the specific outcome that will be true
    • the main artifact, system, repo, environment, or user-facing behavior involved
    • how completion will be verified
    • what is in scope
    • what is out of scope when ambiguity would matter
    • the stop condition for asking the user instead of grinding
  3. Make it quantitative when the domain supports it. Prefer numbers that represent real success, not decorative precision:

    • pass/fail validators: exact tests, checks, CI jobs, evals, commands, or acceptance criteria
    • quality thresholds: latency, error rate, cost, accuracy, recall, precision, coverage, flake rate, bundle size, memory, uptime, completion rate, or manual review criteria
    • artifact constraints: file paths, affected modules, allowed commands, output formats, target environments, deadlines, or maximum blast radius
    • evidence counts: number of reproduced failures, successful reruns, reviewed examples, migrated records, addressed comments, or verified cases
  4. Repair weak goals before setting them.

    • Rewrite vague goals into measurable objectives when local context makes the rewrite safe.
    • Ask one concise clarification question when the missing detail changes the intended outcome or validation.
    • Reject pure activity goals such as "make progress," "keep investigating," "improve things," or "work on X" unless they are sharpened into a verifiable outcome.
  5. Check active goal state before creating a goal.

    • Call get_goal.
    • If there is no active goal and the objective meets the quality bar, call create_goal.
    • If there is an active goal that still matches the user's intent, continue using it instead of creating a duplicate.
    • If there is an active goal that conflicts with the new request, ask whether to finish the current goal, mark it complete if done, or start a separate goal-backed thread.
  6. Create the goal only after it passes the quality bar.

    • Use a single concise objective string.
    • Include the verification evidence in the objective itself.
    • Include scope bounds when they constrain the work.
    • Include a token budget only when the user explicitly requested one.
    • Do not call create_goal for an ordinary multi-step task unless the user explicitly asked for goal-backed work.

Goal Quality Bar

Before create_goal, the objective should answer:

  • What concrete thing will be true when this is done?
  • What evidence will prove it?
  • What quantitative or binary threshold defines success?
  • What scope boundaries matter?
  • What should cause the agent to stop and ask?

Good:

Reduce checkout API p95 latency below 250 ms for the documented slow path by making the smallest safe server-side change, then verify with npm run test:checkout and the existing local latency benchmark showing p95 under 250 ms across 3 consecutive runs.

Good:

Resolve the open review comments on PR 123 that request code changes, update only the affected auth files and tests, and verify with the targeted auth test command plus gh pr view 123 showing no unresolved change-request threads.

Weak:

Make checkout faster.

Weak:

Keep investigating the PR comments.

Quantification Heuristics

  • For bugs, define success as reproduction first, fix second, and a failing-then-passing validator when possible.
  • For tests, name the exact command and required pass condition.
  • For performance, name the metric, target threshold, measurement method, and number of runs.
  • For quality work, define an observable acceptance bar such as reviewed examples, lint/typecheck/test pass, or user-approved artifact.
  • For research, define the decision the research must enable, the sources or systems in scope, and the evidence standard.
  • For operations, define healthy state, monitoring window, failure threshold, and rollback or escalation trigger.

Clarifying Questions

Ask only when a reasonable rewrite would risk pursuing the wrong outcome. Keep the question short and oriented around the missing validator or scope boundary.

Useful question shapes:

  • "What metric should define success here: latency, cost, accuracy, or user-visible behavior?"
  • "Which environment should I verify against: local, staging, or production?"
  • "What is the minimum evidence you want before I mark this goal complete?"

If the user cannot provide a metric, propose the most honest binary validator available and ask for confirmation.

Connect through AnyModel API

This skill runs on whatever model your agent uses. Point Claude Code, Codex or Cursor at AnyModel to run it on Claude, GPT, Gemini and more with one key — pay per token, no subscription.

More from the pack OpenAI skills

ASP.NET Core apps

Guides the agent through current ASP.NET Core practice: choosing Blazor, Razor Pages, MVC or Minimal APIs, Program.cs and middleware order, auth, EF Core, tests and upgrades to .NET 10. Use when building, reviewing or upgrading an ASP.NET Core app.

ChatGPT Apps SDK

Builds ChatGPT apps on the Apps SDK: reads current OpenAI docs first, picks an app archetype, plans MCP tools, adapts an official example or scaffolds a Node server and widget, then tests in Developer Mode. Use when building or fixing an app inside ChatGPT.

CLI creator from API docs

Builds a durable CLI from API docs, an OpenAPI spec, curls or a script: JSON output, doctor and dry-run commands, safe auth, installed on PATH and paired with a companion skill. Use when an agent keeps hitting the same service through ad hoc calls.

Address GitHub PR comments

Fetches all comments, reviews and inline threads on the current branch's GitHub PR with a gh GraphQL script, numbers them and fixes only the ones you pick. Use when a PR has review comments to work through and you want to choose which get changed.

Fix failing GitHub Actions checks

Finds failing GitHub Actions checks on a PR with gh, pulls the logs, extracts the failure snippet and drafts a fix plan, changing code only after approval. Use when a PR's CI is red and you want the cause and a plan before any edit.

Jupyter notebooks

Creates and tidies Jupyter notebooks for experiments or tutorials from bundled templates via a stdlib script, with structure patterns and a run-top-to-bottom checklist. Use when starting a notebook or turning a messy one into something others can rerun.

Linear issues and projects

Works with Linear issues, projects and cycles through Linear's MCP server in a fixed order: setup, scope, read, then write, with sample workflows for triage, sprints and releases. Use when an agent should read or update Linear as part of a task.

Deploy to Netlify

Deploys the current project to Netlify with `npx netlify`: checks the login, links the folder to a site by Git remote or creates one, builds locally and returns a preview or production URL. Use when you want to publish a site to Netlify from your machine.

Browser automation with Playwright CLI

Drives a real browser from the terminal with playwright-cli: snapshots give element refs for clicks and typing, plus screenshots, console, network and traces, with no test files written. Use when a task needs a browser clicked through step by step.

Deploy to Render

Deploys an app to Render from a Git repo: writes and validates a render.yaml Blueprint with services, databases and secrets, or creates one service through the Render MCP server, then checks status and logs. Use when an app needs hosting on Render.

Security best-practice review

Checks Python, JavaScript/TypeScript and Go code against bundled security specs for ten frameworks, writes a report by severity with line numbers and fixes one finding at a time. Use when you explicitly ask for a security best-practice review.

Repository threat model

Writes a repository-grounded threat model: trust boundaries, assets, attacker capabilities and ranked abuse paths with mitigations, asking you to confirm key assumptions before the final file. Use when you explicitly ask to threat model a codebase.

Sentry issues and events

Reads Sentry issues and events through the sentry CLI without changing anything: recent production errors, issue and event details, AI root-cause summaries, with PII redacted. Use when you ask what is failing in production according to Sentry.

Deploy to Vercel

Deploys a project to Vercel, as a preview unless told otherwise, through the Vercel CLI or, without an account, a bundled script that uploads the folder and returns a preview link and a claim link. Use when you want a shareable deployment link fast.

Figma MCP design context

Reads Figma frames through the Figma MCP server in a fixed order (design context, metadata, screenshot) and rebuilds them with the project's components and tokens; also covers server setup in Codex. Use when connecting Figma MCP or coding from a frame link.

Figma use_figma prerequisite

Sets the rules an agent must load before every use_figma call that runs Plugin API JavaScript in a Figma file: return values, page resets, colours, fonts, node IDs, small validated steps. Use when creating or editing anything inside a Figma file.

Implement a Figma design in code

Implements a Figma frame or component as code in your repo with 1:1 visual parity: fetches context and a screenshot, maps the output to project tokens and components, then runs a validation checklist. Use when a Figma link must become production UI.

Generate a Figma design from an app

Builds or updates a full screen in Figma from code or a description, section by section, using the file's published components, variables and styles instead of hardcoded values. Use when a page from your app should exist as a Figma screen.

Figma design system from a codebase

Builds a Figma design system library from a codebase in five supervised phases: discovery, variables and styles, page structure, components one by one, QA. Use when a product needs a Figma library that matches its code tokens and components.

Figma Code Connect components

Links published Figma components to the code components that implement them via Code Connect: finds unmapped ones, matches them in the codebase, maps only what the user approves. Use when a Figma library and its code both exist but are not linked.

Figma design system rules

Writes project rules for turning Figma designs into code into CLAUDE.md, AGENTS.md or a Cursor rules file, based on Figma's rule template and an analysis of the codebase. Use when setting up an agent for regular Figma-to-code work in a repo.

Create a new Figma file

Creates a blank Figma design file or FigJam board in your drafts, resolving the plan through whoami, and returns the file key and URL. Use when the next Figma step needs a fresh file to write into.