AI Skills Reuse Instructions. Contracts Also Ensure Output Quality.

You probably already use skills: files holding your instructions, your format rules, your domain context, so you do not restate them every session in which you use AI. However, skills have two major blind spots: they do not check whether the output actually meets your requirements before it reaches you, nor do they keep a record of every run unless you specifically instruct them to.

Contracts, a new feature for modern agents, solve both.

---

What skills do, and what they do not

Skills and contracts share more than they differ: both are files written once and reused across runs, both can be used by anyone who has the file, and neither requires re-explaining requirements each time.

The difference is that skills focus on how the AI behaves during a session, whereas contracts focus on what the output should look like. This makes it more likely that the AI achieves the objective you gave it, without having to spend hours on describing exactly how it should proceed.

Moreover, with contracts, every run is saved automatically in a dated folder, and in a format that’s easy to audit, especially if it contains multiple steps. Conversely, with skills, auditable logs and permanent outputs occur only if you specify them.

---

What a contract looks like in practice

Imagine a back-office team at a manufacturing company that needs a one-page supplier risk summary every Monday. The format must be consistent, because managers scan it quickly, and the team also needs to compare results week over week.

Without a contract, here is what happens. Someone collects the data, opens a chat, runs a skill, and gets a report. Every Monday, the report is slightly different in its format because the skill specifies a procedure, not the output. This means that the report is prone to containing errors or missing elements.

So, the team decides to implement a contract. Here is what the file looks like:

---
name: supplier-risk-update
kind: service
---

### Description
Weekly one-page supplier risk summary for operations managers.

### Requires
- `logistics-data`: incoming delivery records for the week, including any delays
- `quality-log`: quality incidents recorded this week
- `price-notices`: any supplier price change notices received this week

### Ensures
- `report`: a one-page update with three sections:
    - Delivery delays: each item includes the supplier name, days delayed,
      and a severity rating (low, medium, high)
    - Quality incidents: each item includes supplier, description,
      and recommended action
    - Price changes: each item includes supplier, product,
      percentage change, and effective date

### Strategies
- If the logistics data is incomplete, note the gap in the delivery
  delays section rather than skipping it
- Severity ratings should reflect operational impact, not just delay length

The “Ensures” section

The ### Ensures section describes what the output must contain for it to be satisfactory.

The “Requires” section

The ### Requires section lists exactly what the user must provide each run. It ensures that the contract isn’t run when inputs are missing, preventing guesses and hallucinations.

The “Strategies” section

It handles edge cases, such as what to do when an input is incomplete. It is optional, but useful when the inputs are not always clean.

The “Execution” section

Not depicted in the example above, it contains a series of steps. It is optional, and should only be provided when the steps have clear boundaries and must be executed in a specific sequence.

Common mistakes

• Spending more time writing the “Execution” and “Strategies” sections than the “Ensures” section.
• Adding to the “Execution” and “Strategies” sections content that belongs to the “Ensures” section.
• Writing a generic “Ensures” section. For example, writing “Ensure a good summary” gives the program nothing concrete against which to verify the output. Conversely, “a one-page update with three sections, each item including severity and a recommended action, no section omitted” is something that can be evaluated more reliably.

---

How to start using contracts

First, you must install the OpenProse framework:

1. Install the open-prose skill: npx skills add openprose/prose
2. Restart your agent (Claude, GPT, etc.)
3. Ask the agent to “read the contracts documentation at docs.openprose.ai/agents/for-ai-agents and then help me write a contract to do X”, where X is a recurring task of yours which produces a standard output.
4. Ask it to run the contract once.
5. The first time, the result will not be perfect. Let your agent know all your feedback and edit the contract accordingly.
6. The second run will go much better.