agentsclimarketplace

Llm friendly context

Skill shinpr/claude-code-workflows/skills/llm-friendly-context

Clarifies inputs, outputs, success criteria, decisions, and unresolved conditions so downstream consumers can execute without guessing. Use when writing or revising LLM-facing prompts, handoffs, planning artifacts, reviews, reports, or generated instructions.From its SKILL.md

Install
npx -y skills add shinpr/claude-code-workflows --skill llm-friendly-context

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

SKILL.md

5.1 KB, as published. Nobody here has run it

LLM-Friendly Context

The goal is stable downstream execution: the next consumer should know what to read, what to do, what counts as success, and which unresolved decisions can change the result.

Core Rules

  1. Use positive, executable instructions

    • State what the next consumer should do.
    • Convert quality policies into positive criteria.
    • Keep a prohibition only when it protects an irreversible boundary or shipped contract. Name the protected condition and the allowed action.
    • Example: "Preserve existing public API behavior across the documented compatibility cases."
  2. Make vague instructions concrete

    • Replace subjective terms with observable conditions, paths, commands, schemas, examples, or decision rules.
    • Terms that often need clarification when they leave a decision to the next consumer: appropriate, proper, related, existing behavior, optional, as needed, if needed, per convention, unresolved alternatives, TBD, placeholder.
  3. Specify output shape

    • Use the sections, fields, table columns, JSON keys, or checklist items the consumer uses.
    • For handoffs, include only produced artifact paths and status fields that control the next transition.
  4. Provide necessary context

    • Include the purpose, source artifacts, hard constraints, accepted decisions, and unresolved conditions.
    • Prefer concrete file paths and section hints over broad module names.
    • Follow references while they can change an in-scope decision, action, or verification result.
  5. Decompose complex work into verifiable steps

    • Split work with 3+ objectives or sequential dependencies into ordered steps.
    • Each step needs a checkpoint: what evidence proves it is complete.
  6. Permit uncertainty explicitly

    • Resolve missing operational detail from referenced artifacts and repository evidence before treating it as unresolved.
    • Record remaining uncertainty with its effect, required input, and decision owner. Make reversible repository-local choices when governing evidence resolves them.
  7. Keep constraints proportionate

    • Add only constraints that reduce ambiguity or preserve a real requirement.
    • Keep simple downstream tasks lightweight when the target action, context, and success criteria are already clear.
    • Apply minimal, a few lines, and explicit line estimates to the completed diff as one total budget.

Rewrite Patterns

Use these rewrites before treating a prompt, handoff, or artifact as complete.

Ambiguous formRewrite as
optional used as an unresolved choiceRequired, omitted, or required only under a named condition
Multiple alternatives that the next consumer must choose betweenThe selected option, or a deterministic decision rule
as needed / if neededThe triggering condition and required action
per conventionThe file, function, test, or documented convention to follow
related filesSpecific paths, globs, or search hints
existing behaviorThe observable behavior, source file, test, API response, or UI state to preserve
placeholderExact temporary value/behavior, allowed dependencies, and verification expectation
TBD used as a placeholder for required informationA blocking unresolved item with owner, required input, and decision effect
appropriate / properA measurable criterion or checklist

Handoff Checklist

Before sending a prompt or artifact to another consumer, verify:

  • The target action is explicit.
  • Required input paths, source artifacts, and decision-relevant facts are named.
  • Accepted decisions and constraints use one canonical wording.
  • Output format or expected status fields are specified.
  • Success criteria are observable.
  • Ambiguous expressions have been rewritten or marked as unresolved.
  • Each instruction states the allowed action; each retained prohibition names the protected condition and allowed alternative.
  • The next consumer can complete its scope from the supplied purpose, sources, criteria, and evidence, or return the exact unresolved decision and owner.

Generated Artifact Checklist

Before writing or finalizing a generated document:

  • Each requirement, claim, task, test skeleton, or review finding has enough source context to trace why it exists.
  • Every executable instruction names the target, action, and expected result.
  • Verification steps say what to run or observe and what result proves success.
  • Each instruction states the allowed action; each retained prohibition names the protected condition and allowed alternative.
  • If an artifact is derived from another artifact, copied decisions stay consistent in wording and meaning.
  • If downstream work is blocked by missing information, the artifact records the missing input, decision owner, and effect.

What ships with it

Read from the repository

Just SKILL.md. No reference files, no scripts.

Gives 0 of the 12 instructions most context ai engineering skills give

Counted across 1,328 of the 2,349 authors here whose files we hold, read 2026-09-06

  • Dispatch a fresh subagent for each taskin 76 of 1328, across 59 files
  • Perform spec compliance review before code quality reviewin 44 of 1328, across 34 files
  • Dispatch a final code reviewer after all tasksin 38 of 1328, across 26 files
  • Answer subagent questions before allowing implementationin 36 of 1328, across 26 files
  • Use the least powerful model capable of the taskin 33 of 1328, across 26 files
  • Create a TodoWrite list for all tasksin 32 of 1328, across 22 files
  • Perform a task review after each implementationin 31 of 1328, across 24 files
  • Extract all tasks and context from the planin 29 of 1328, across 20 files
  • Provide full task text to subagentsin 28 of 1328, across 20 files
  • Use git worktrees for isolated workspacesin 25 of 1328, across 20 files
  • Specify the model explicitly when dispatching a subagentin 23 of 1328, across 18 files
  • Execute all tasks from the plan without stoppingin 21 of 1328, across 16 files

Said here and by no other author read

  • Use positive and executable instructions
  • Replace subjective terms with observable conditions
  • Provide purpose and source artifacts
  • Decompose complex work into verifiable steps
  • Define checkpoints for each step
  • Record remaining uncertainty with decision owners

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once.

Keep looking

Skills are one crate of 611,919. Ordering is by how many stacks a row turns up in, so the top of any crate is what has actually been picked rather than what has the most stars.