Discovery

In most projects the thinking gets lost before the code is written. Someone writes the brief, the personas and the decisions once. By the time a ticket reaches an agent, nobody opens those pages again. The agent gets a title and three lines under it, and guesses the rest.

Discovery is a set of skills. They work an idea out with you and write the result into Confluence and Jira, where your team already looks. At the end you have a monoceros init command for the stack you chose, and a backlog whose stories hold everything someone needs to build them.

What you need

A workbench with Claude Code in it, and a Confluence and Jira you may write to. The discovery-atlassian template builds that workbench in one command. The skills, the build roles and the Atlassian CLI are already in it. Confluence and Jira are yours: your instance, your login. The skills write with your rights and no more. Setup shows the whole way, from the installer to the first question of the brief.

Neither of them has to be empty. In Confluence you name one page, and everything the skills write goes under that page. In Jira you name a project, and the issues go there, next to whatever the project already holds.

If you set up a new project for this, it needs the issue types epic, story and task. The backlog skill uses all three. The statuses are yours. No skill reads a status and none changes one, so your team keeps the workflow it has. If you start from nothing, Open, In Progress, In Review and Done are enough.

Two pages come with a diagram, the domain model and the technical frame. The skill draws it and attaches it as an image, so your Confluence needs no extra app.

Without a connection the skills write local Markdown files instead and tell you where they are. That works, but it misses the point. Discovery pays off because the result sits where your team looks.

The Monoceros docs connector ships with the plugin and needs no login. The technical frame uses it to read the current component catalog, so it does not have to guess component names.

The chain

Seven skills, in this order. Each one reads what the earlier ones wrote, so the later ones stay short.

Brief The problem, who has it, what the product does, and what it will not do. One page, and everything else builds on it.

Personas and journeys Who uses the product and the path each of them takes. The backlog later follows these journeys.

Domain model Entities, relationships, attributes and states. Every story uses these names.

Design brief North star, principles, visual direction and the key screens. Enough to generate a design system from it.

Technical frame The stack decisions, and the monoceros init command that goes with them.

Backlog Epics and stories in Jira. Each story promises one function and holds what someone needs to build it.

Project files The README and the agent instructions the project directory starts with.

You can run a single skill on its own. Most of them read a page from an earlier step, so the order above is the fastest way through. But nothing stops you from writing the brief today and the backlog three weeks later.

The same is true for a product that already runs. You start with the first page you do not have yet, and you bring what already exists into the dialog. The skills work from what you tell them and from the pages above them. They do not read your code. So a domain model for a running product says what you tell the skill today.

How the skills behave

Three rules apply to all of them, and they are the reason the result is worth reading.

They invent nothing. A skill writes no requirement, property or condition that you did not say and that no earlier page holds. If something is missing, it asks you. It does not fill the gap with something that sounds plausible.

They propose instead of asking you to fill in a form. Every section starts as a concrete proposal, and you correct it, one topic at a time.

They write in your language. Text, headings and labels follow the language of your conversation. The technical markers in the page templates stay as they are. The project files are English unless you ask for something else, because people read a public README who never saw the discovery.

Where it leads

The technical frame gives you the monoceros init command for the stack you chose. From there you go to your first workbench, and the stories go to the Claude Code roles: one plans, one implements, one reviews the result against the plan.

The idea-to-code page tells the whole chain as one story.

Other backends

The marketplace holds one plugin per backend, and you install the one for the tools you use. discovery-atlassian covers Confluence and Jira, and it is the one that exists today. A Notion plugin is planned.

The same marketplace also holds quickstart, a single skill for the short way in. You describe what you want to build, and it gives you the init, apply and run commands plus a build prompt. It writes no discovery pages at all. See the Claude skill page.