sneak 3601ebf2a1
check / check (push) Successful in 1m56s
Replace script/update-policy with script/write-upstream-policy-files and script/commit-upstream-policy-files (closes #165)
script/write-upstream-policy-files fetches the shared policy files
from prompts over HTTP and writes them into a repo clone, or into its
own repo. It commits nothing. It keeps a repo's own entries in
.gitignore, .dockerignore, .editorconfig and .golangci.yml. It stops
before writing when one of those files, or a repo's own script of the
same name, has a line it cannot keep.

script/commit-upstream-policy-files replaces script/update-policy. It
fetches the current script/write-upstream-policy-files, runs it on its
own repo and commits the result without pushing.
make commit-upstream-policy-files replaces make update-policy.

test/commit-upstream-policy-files.sh replaces test/update-policy.sh.
The Dockerfile's test stage runs it with no timeout, with coreutils so
that cp is GNU cp.

Model: opus-5-5
2026-11-16 22:15:52 +00:00

prompts

prompts is an MIT-licensed collection of LLM prompts by @sneak, including development policy prompts and other useful prompts for working with large language models.

Quick Start

Existing Repo

Run from within the repo you want to bring up to standards. Clone the prompts repo once, then run both commands in order.

export TD="$(mktemp -d)"
git clone --depth 1 https://git.eeqj.de/sneak/prompts.git "$TD"

Repository structure and policies:

claude "Read $TD/prompts/REPO_POLICIES.md and
$TD/prompts/EXISTING_REPO_CHECKLIST.md, then bring this repo up to those
standards. Your scope is repo scaffolding and policy compliance:
Makefile, Dockerfile, .dockerignore, .gitignore, .editorconfig, CI
workflow, README sections, LICENSE, REPO_POLICIES.md, and any
language-specific config files (.golangci.yml, .prettierrc, etc.).
You must also run the formatter (make fmt) and fix any linter errors
(make lint) so that make check passes — this will touch source code,
but do not restructure, refactor, or rewrite any application logic.
Follow the policies yourself: work on a feature branch, never git add -A,
and make each logical change a separate commit (e.g. one commit for
formatting, one for linter fixes, one for README updates, one for each
new repo file added, etc.)."

Code style and conventions:

claude "Read $TD/prompts/CODE_STYLEGUIDE.md and whichever other
documents in $TD/prompts/ apply to this repo (API_POLICIES.md,
CODE_STYLEGUIDE_GO.md, CODE_STYLEGUIDE_JS.md, CODE_STYLEGUIDE_PYTHON.md,
GO_HTTP_SERVER_CONVENTIONS.md). Then review the application code in this
repo and bring it into compliance with those coding standards. Your scope
is application code structure and style: naming, patterns, error
handling, project layout, and conventions described in the styleguides.
Do not modify repo scaffolding (Makefile, Dockerfile, CI workflow,
.gitignore, .editorconfig, etc.) — only application code. Work on a
feature branch, never git add -A, and make each logical change a
separate commit."

New Repo

Run from inside the directory where you want to create a new repo. Clone the prompts repo once, then run both commands in order.

export TD="$(mktemp -d)"
git clone --depth 1 https://git.eeqj.de/sneak/prompts.git "$TD"

Repository scaffolding:

claude "Read $TD/prompts/REPO_POLICIES.md and
$TD/prompts/NEW_REPO_CHECKLIST.md, then set up this new repo according
to those standards. Your scope is repo structure and required files:
README.md, LICENSE, REPO_POLICIES.md, Makefile, Dockerfile, .dockerignore,
.gitignore, .editorconfig, CI workflow, and language-specific config.
Run the formatter (make fmt) and fix any linter errors (make lint) so
that make check passes — this will touch source code, but do not
restructure, refactor, or rewrite any application logic. Follow the
policies yourself: work on a feature branch, never git add -A, and make
each logical change a separate commit (e.g. one commit for formatting,
one for linter fixes, one for README, one for each new repo file, etc.)."

Code style and conventions:

claude "Read $TD/prompts/CODE_STYLEGUIDE.md and whichever other
documents in $TD/prompts/ apply to this repo (API_POLICIES.md,
CODE_STYLEGUIDE_GO.md, CODE_STYLEGUIDE_JS.md, CODE_STYLEGUIDE_PYTHON.md,
GO_HTTP_SERVER_CONVENTIONS.md). Then review the application code in this
repo and bring it into compliance with those coding standards. Your scope
is application code structure and style: naming, patterns, error
handling, project layout, and conventions described in the styleguides.
Do not modify repo scaffolding (Makefile, Dockerfile, CI workflow,
.gitignore, .editorconfig, etc.) — only application code. Work on a
feature branch, never git add -A, and make each logical change a
separate commit."

Getting Started

git clone https://git.eeqj.de/sneak/prompts.git
cd prompts

Prompts are stored as Markdown files in prompts/. Copy or reference them as needed in your projects.

Entrypoints

This repository adheres to the Scripts to Rule Them All standard: normalized scripts in script/ are the entrypoints for the development workflow, and the Makefile targets are thin shims that call them. The scripts are POSIX sh (not bash) so they run in minimal containers such as alpine. We provide:

  • script/bootstrap — install all dependencies (yarn install --immutable)
  • script/setup — set up the repo for development after a fresh clone: runs script/bootstrap, then script/install-precommit
  • script/projectname — output the project name (our own extension); used by script/docker for the image tag
  • script/test — docker build --target test --output type=cacheonly ., building the test phase of the Dockerfile, which runs test/commit-upstream-policy-files.sh, without writing an image
  • script/lint — docker build --target lint --output type=cacheonly ., building the lint phase, which runs prettier over the markdown files, without writing an image
  • script/fmt — format all markdown files with prettier (writes; native, not in a container)
  • script/fmt-check — check formatting (read-only; native)
  • script/check — run all checks: test, lint, fmt-check (our own extension); builds no image of its own
  • script/docker — docker build --build-arg VERSION="$version" -t prompts ., the tag coming from script/projectname (byte-identical across repos)
  • script/cibuild — cd to the repo root, run script/bootstrap, run script/check, compute version from git describe, then docker build --build-arg VERSION="$version" -t prompts . (what CI runs; it bootstraps because CI checks out and runs this alone while script/fmt-check is native)
  • script/precommit — run by the git pre-commit hook (our own extension); calls script/check
  • script/install-precommit — installs the git pre-commit hook (our own extension); make hooks shims to it
  • script/write-upstream-policy-files — fetch the vendored policy files from this repo over HTTP and write them into a repo (our own extension). It writes into the repo given as its argument, or its own repo with no argument. It stops when its target is this repo.
  • script/commit-upstream-policy-files — fetch the current script/write-upstream-policy-files, run it on its own repo and commit the result without pushing (our own extension). It is for the repos that vendor the policy files. It stops when run here.

make hooks installs the pre-commit hook that runs script/precommit.

The builds use Docker's normal cache: a step runs again only when its inputs change. This repo's own Dockerfile installs git, make, node and yarn right after FROM in every stage, so a change to script/ keeps that layer.

Rationale

LLM prompts, especially development policies, benefit from version control and a single authoritative source. This repo provides a central place to maintain, share, and evolve prompts across projects.

Design

The repository is a collection of Markdown files organized in the prompts/ subdirectory. Each file contains one or more related prompts or policy documents. There is no build step or runtime component; the prompts are consumed by copying them into other projects or referencing them directly.

See Also

  • clawpub — Real-world examples, rationale, and operational lessons from applying these policies with an OpenClaw AI agent. Includes detailed documentation on how the interlocking check system (CI → Docker → Makefile → tests/lint/fmt) works in practice, why checklists complement prose policies, and failure stories from production use.

TODO

  • Add more prompt templates for common development tasks

License

MIT. See LICENSE.

Author

@sneak

S
Description
No description provided
Readme MIT
7.1 MiB
0 Stars 1 Watchers 0 Forks
Languages
Shell 83%
Dockerfile 13.5%
Makefile 3.5%