jules-prompts

# Jules Prompts

> Agent Skills that take any idea, software or hardware, in any state, to a working product and keep it improving. Every decision is backed by verified evidence, every change is traced to the goal, what people and agents use is designed and tested with them, and the skills catch the failures agents actually have: work that reads as finished and is not, setup that reports success while broken, tests that cannot fail, and commands to the physical world that were accepted but never happened. Each skill is one self-contained Markdown file in the Agent Skills format, and none depends on a particular agent or harness.

To use this site as an agent:

1. Pick the skill below whose description matches your task.
2. Fetch its SKILL.md and follow it. It needs nothing else from this site.
3. Report every claim as holds, broken or skipped, and end with how many of each.

Discovery index, with a SHA-256 digest per skill: https://jules-prompts.wecanuseai.com/.well-known/agent-skills/index.json
Standing rules for every task, for a project's AGENTS.md: https://jules-prompts.wecanuseai.com/harness/AGENTS.md
The ledger check, for a project's CI (Python, no dependencies): https://jules-prompts.wecanuseai.com/harness/check_trace.py
The whole path from idea to continuous improvement, each step with its gate: https://jules-prompts.wecanuseai.com/workflow.json
The test a self-built agent harness must pass (Python and git, nothing else): https://jules-prompts.wecanuseai.com/harness/conformance.py

## Where to start, by the state the project is in

- Broken for people right now → `handle-an-incident` then `keep-it-on-course`. Stop the harm and restore by the fastest action already tried; the cause, the fix and the prevention come after, on a copy.
- An idea, and only a language model to build it with → `run-autonomously` then `start-from-an-idea`. The model builds its own harness and tools and proves them, the person is asked everything only they can answer in one sitting, and the build then runs without waiting.
- An idea, and an agent that already works → `start-from-an-idea` then `design-the-experience`. What it takes, the costly decisions with evidence, a pipeline anyone can run, and one slice end to end.
- A project that already exists, in any state: a prototype, a half-built or vibe-coded build, an inherited codebase, or a working product with gaps → `start-from-an-idea` then `repair-setup-script` then `design-the-experience` then `take-to-production` then `release-to-people`. Found it again on paper: the ledger written from what is there, every decision it embodies recorded with the evidence it had, and those nobody can justify marked for revisiting. Then make it run from cold, and close the gap.
- Live, and it has to keep working and getting better → `keep-it-on-course` then `change-with-a-reason` then `release-to-people`. Every measure taken again from its source, the next improvements ranked by what they move, on a steady cadence for as long as it serves anyone.
- Stalled, abandoned or drifting → `keep-it-on-course` then `choose-with-evidence` then `change-with-a-reason`. The review finds the route that is blocked and the next route to the same goal, whether it is in the product, the way in or the channel. Nothing is declared dead.
- A request, however it is worded: 'optimise it', 'make it pretty', 'add AI' → `change-with-a-reason`. Translated into the measure it moves, verified before and after, built through every layer it touches.
- A choice between options: a tool, a vendor, a part, a design, a route → `choose-with-evidence`. Real options, criteria from the goal, at least two backings with one verified, and a way out.
- Work an agent produced → `review-an-agent-pr` then `qa-an-agents-tests`. Every claim it makes checked, and every new test seen to fail.
- Alongside every step, when the project is private, proprietary or offline, or any of its work must not leave → `keep-it-confidential`.
- Alongside every step, when it moves, heats, dispenses, spends or sends: hardware, devices or real-world services → `act-on-the-physical-world`.

## Start here

- [Run a Project Autonomously, from One Model and One Person](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/run-autonomously/SKILL.md): To take one language model and one person to a project that builds itself. The model builds its own agent harness and every tool it lacks, from a specification it can prove against a test. The person is asked everything only they can answer at the start, and development then runs without waiting. It is safe because of a sandbox, checkpoints and standing limits, and it is correct because nothing counts as done until its checks pass. Offline, online or both, unattended, supervised or by hand.
- [Start a Project from an Idea](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/start-from-an-idea/SKILL.md): To take any idea, software or physical, to a foundation it can grow on without later regret. It works out what it takes to make the idea happen and how that is paid for, makes the costly-to-reverse decisions with verified evidence, gives it a pipeline a person or an agent can run and one slice working end to end, and writes a ledger that gives every later change a reason.
- [Design the Experience, with Evidence](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/design-the-experience/SKILL.md): To design what people and agents see, do and hear when they use a product, on a screen, a command line, an API, a voice or a device, as one design with the architecture. Every flow, state, word and look has a reason and is tested with real people or stand-ins labelled as such. Every action can be operated by a person, an agent or automation, and the result is measured, not admired.
- [Change a Project with a Reason](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/change-with-a-reason/SKILL.md): To turn any requested change, including a vague one like "optimise it", "make it scalable" or "add AI", into one that traces to the project's goal, is verified before and after, is built through every layer it touches, and leaves nothing detached. Nothing asked for is dismissed. When the named part already meets its target, the work goes where the owner's feeling comes from.
- [Take a Project to Production Quality](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/take-to-production/SKILL.md): To take a project in any state, software or physical, to production quality. It does its one job dependably and securely on every platform its people use, loses and leaks nothing, feels finished, carries nothing it does not need, and every area that decides this, from security and privacy to operations, is checked rather than assumed.
- [Keep a Project on Course and Improving](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/keep-it-on-course/SKILL.md): To keep a project working and getting better, at every milestone and continuously after launch. Every measure is taken again from its source, every course change and revisit condition is checked, whatever nothing serves is removed, and both a person and an agent run the pipeline. The next improvements are chosen by what they move, so the project never drifts, stalls or is left half-done.
- [Keep a Project Confidential, Offline First](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/keep-it-confidential/SKILL.md): To keep a private or proprietary project's code, data, designs and plans inside the places the owner chose, whether it is built fully offline with local agents and models or has to use the internet. Every channel that can carry the work out (hosting, sync, agents and model providers, registries, telemetry, crash reports, searches) is mapped, closed or controlled, and checked in a network log. The whole pipeline is proved to run with the network off.
- [Act on the Physical World, and Prove It Happened](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/act-on-the-physical-world/SKILL.md): To make an agent's commands to hardware, devices, machines and real-world services safe to issue and provable afterwards, because a command that was accepted is not a valve that closed.

## Every other skill

- [Automate a Workflow That Can Report Its Own Failure](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/automate-a-workflow/SKILL.md): To replace a repeated manual sequence with a script whose main job is being able to tell you whether the work actually happened, because an automation that reports success while blind is worse than doing it by hand.
- [Fix a Bug, Failing Test First](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/fix-a-bug-test-first/SKILL.md): To fix a reported bug in an order that proves the fix worked, by making the test fail for the reported reason before any code changes.
- [Isolate Tests from External Services](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/isolate-tests-from-services/SKILL.md): To make a test suite runnable in an agent's sandbox by removing its dependence on services it cannot start.
- [Map the Architecture](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/map-the-architecture/SKILL.md): To describe how the system actually works, by deriving it from what runs and what imports what rather than from the folder names.
- [Repair the Environment Setup Script](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/repair-setup-script/SKILL.md): To diagnose and repair the setup script so agent tasks stop failing before any code is written.
- [Scope a Vague Issue](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/scope-a-vague-issue/SKILL.md): To turn an underspecified bug report into a reproducible, testable task before any fix is attempted.
- [Translate the Docs Without Forking Them](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/translate-the-docs/SKILL.md): To add a language to a project's documentation together with the machinery that says when a translation has gone stale, because a translation nobody can tell is out of date is worse than no translation.
- [Update Dependencies](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/update-dependencies/SKILL.md): To bring a project's dependencies, runtime and build tools up to date in small steps that each prove they changed what they say, so staying current never becomes a rewrite. Every major version's breaking changes are checked against the code, the lockfile is regenerated rather than edited, nothing new arrives unexamined, and every pin carries a reason and a date to revisit.
- [Verify a Database Migration Before It Meets Real Data](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/verify-a-migration/SKILL.md): To find what a migration does at production row counts, on the production engine, and on the way back down, none of which a dev database can show you.
- [Choose Between Options with Evidence](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/choose-with-evidence/SKILL.md): To make a consequential choice, such as a vendor, platform, part, provider, library or where a resource comes from, against criteria taken from the project's goal. Evidence is in proportion to the stakes, every number is redone, and the choice keeps a way out and a condition that reopens it. It can also choose several options, or one after another.
- [Handle an Incident, Restore First and Then Prevent It](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/handle-an-incident/SKILL.md): To bring a live product back for the people it failed, then make the failure unable to recur. Stop the harm to data, restore by an action already tried, tell people and keep the evidence; then prove the cause with a failing test, fix it through the normal gates, put everyone right, and close the class of failure in the system.
- [Release a Product to Its People, and Hear Back](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/release-to-people/SKILL.md): To take a product that meets its bar to the people it is for, and hear back. Every way in is walked from a clean device, listings and legal texts match the product, the release is staged and pauses itself, people are told where they already are, and someone answers. A quiet channel gets the next route, never a verdict on the idea.
- [Security Review of Agent-Written Code](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/security-review-agent-code/SKILL.md): To review a change an agent wrote for the security defects agents specifically introduce.
- [Prove the Documentation Against the Code](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/prove-the-docs/SKILL.md): To find the claims in the docs that were true when written and are not true now, by executing each one rather than reading it.
- [QA the Tests an Agent Wrote](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/qa-an-agents-tests/SKILL.md): To find the tests that cannot fail, whether an agent wrote them from the implementation or they came with a fix, by breaking the behaviour or putting the defect back and watching each test go red for the stated reason.
- [Repair a Pipeline That Is Green Without Checking Anything](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/repair-a-green-pipeline/SKILL.md): To find the CI steps that pass because they are not running what they claim, and make each one able to fail again.
- [Review an Agent-Written Pull Request](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/review-an-agent-pr/SKILL.md): To review a pull request an agent wrote, against the failure modes agents actually have.
- [Run the Error Paths](https://jules-prompts.wecanuseai.com/.well-known/agent-skills/run-the-error-paths/SKILL.md): To find the failure handling that has never once executed, by causing each failure on purpose and watching what the code actually does.

## Optional

- [Source repository](https://github.com/melbinjp/jules-prompts): the procedures, the planted-failure fixtures that show a skill going red, the scorer, a plugin bundle and an MCP server