> ## Documentation Index
> Fetch the complete documentation index at: https://resources.athenaintel.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Plan before you build: a one-page spec and the interview that writes it

> Athena can build an app in an hour and interview you to write the one-page plan and test cases that prove it works.

> Athena can build an app in an hour and interview you first to write a one-page plan with the problem, who uses it, what goes in and out, which building blocks to use, and the test cases that prove it works. Spend twenty minutes on that plan so you build the right thing and can turn its test cases directly into checks for the build.

## Why plan if the build takes an hour?

Athena builds what you ask for in an hour, so a clear plan makes sure you ask for the right thing. Writing the plan first solves three common problems:

* You solve the actual problem, instead of building a dashboard when the team needed a list of items to review.
* Everyone agrees on what "working" means, because the test cases define it up front.
* Engineers can take the build over, because teams that want a written requirement already have one.

## What goes in the plan?

| Section | One or two lines on |
| - | - |
| Problem | What is slow or goes wrong today, and for whom |
| User | Who opens it, how often, and what they do with the result |
| Trigger | What starts the work: a person, a schedule, a file, or an event |
| Inputs | The files, fields, and systems it reads, with a real example attached |
| Output | What it produces and where that goes |
| Judgment | Which steps need judgment, and which follow fixed rules |
| Changes | Every system it changes, and who approves each change |
| Data | What it stores, how sensitive it is, and how long to keep it |
| Test cases | Five to ten examples, each with the result you expect |
| Not in this version | What it will not do yet |
| Owner | Who looks after it after launch |
| Tier | Personal, team, business-critical, or public |

Your Trigger and Judgment answers point to the right building blocks. Fixed steps on a schedule point to an [Automation](https://resources.athenaintel.com/docs/build-guides/aop-automation-or-agent.md), reading and deciding points to an AOP (Agent Operating Procedure), and people entering records all day points to an [Application](https://resources.athenaintel.com/docs/build-guides/application-computer-or-user-interface.md).

![Plan, build, check. Answer questions, one at a time. Write a one-page plan with the problem, who uses it, what goes in and out, and how to check it. Build using the parts the plan calls for. Check by running the checks from the plan, pass or fail. Return arrows read fix it and check again, and the plan was wrong.](https://mintcdn.com/athenaintelligence-e46bc9d3/U4e92C1IcbO5Ytjz/images/build-guides/spec-before-you-build-1.webp?fit=max\&auto=format\&n=U4e92C1IcbO5Ytjz\&q=85\&s=576ee2444a77664284e1df8f52405b7b)

## How does Athena interview me?

Athena interviews you one question at a time, bases each question on your last answer, and often suggests an answer you can accept with a click.

Save the text below as a Skill in your workspace and add it to your Agent. Then start a conversation and say "interview me for a spec".

Save it as a Skill in Athena

Start the interview in Athena

```markdown theme={null}
---
name: spec-interview
description: Interview the user to produce a one-page build spec before
  any app, AOP or Automation is built. Load when the user asks to build
  something new, asks for a spec, or says "interview me".
---

# Spec interview

Ask one question at a time. Use the question tool. Offer choices with a
recommended answer whenever the options are knowable. Do not start
building until the spec is confirmed.

## Order
1. Problem: what happens today, how often, what it costs.
2. User: who opens the result and what they do next.
3. Trigger: what starts the work.
4. Inputs: ask for one real example file or record. Read it before
   asking the next question.
5. Output: format and destination.
6. Judgment: walk the steps and mark each one "rule" or "judgment".
7. Writes: every system changed, and who approves each change.
8. Data: what is stored, its sensitivity, retention.
9. Acceptance checks: propose five cases from the example, including
   one that should be rejected. Ask the user to correct them.
10. Out of scope, owner, tier.

## Rules
- If an answer is vague, ask for the last real time it happened.
- If two answers conflict, show both and ask which is right.
- Never invent a number, a system name or a policy. Ask.
- Stop asking when every section has an answer or "not needed".

## Output
1. The one-page spec as a document in the workspace.
2. A recommended set of building blocks with one line of reason each.
3. The acceptance checks as a table: case, input, expected result.
4. Open questions the user could not answer.

Ask the user to confirm the spec before building.
```

You can change the questions to fit your team. For example, a services firm might ask what the client calls the process, while a regulated team might ask which control the work supports.

## How does the plan become an app?

Turn each test case into a check:

1. Have the business owner read the plan and sign off on the test cases.
2. Pick the building blocks using the plan's suggestion, or see [When to use what](https://resources.athenaintel.com/docs/build-guides/which-building-block.md).
3. Give Athena the plan to start building, and include [the build standard](https://resources.athenaintel.com/docs/build-guides/build-standard.md) if you are building an app.
4. Turn the test cases into checks, as shown in the next section.
5. Keep the plan current, since the next owner will read it first.

## How do I prove it works?

| What you built | How to check it |
| - | - |
| AOP | Run a test for each test case without making real changes, save good runs as examples, and replay them before each new version |
| Automation | Run a test to check the order of steps and what passes between them, and test each AOP inside it on its own |
| Application | Ask Athena to turn the test cases into automated tests and run them before each release |
| Anything | Include one case that the build must refuse, so you verify it rejects bad input |

## What to plan for

Keep the interview Skill in your workspace and make planning a team habit, since Athena lets you start building without a plan.

Talk to whoever does the work today with a real example open when you run the interview. When the business process changes later, update the test cases first and run them again.

## Questions teams ask

> [accordion] Is this a product requirements document?
>
> It is a one-page version of one. An engineer can take over from it, and a reviewer can check the work against it. You can expand it for business-critical or public apps.

> [accordion] Can the interview run as an AOP?
>
> Yes. Put the same instructions in an AOP so anyone on the team can start it from a form, and send the finished plan into a set folder.

> [accordion] We already built the prototype. Is it too late?
>
> No. Run the interview and write the test cases, then test the prototype against them to see whether to keep it.

> [accordion] Who owns the plan?
>
> The business owner owns the problem, the user, and the test cases. The builder owns the choice of blocks and the build.

> [card] [See it work](https://athenaintel.com/demo/)
>
> Thirty minutes, your workflow, and you leave with the work product.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.