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

# Design with EDK

> Design Elementum processes and record experiences before implementing them.

<Warning>
  **Limited Release.** The EDK is currently in limited release and is not available to all customers. Commands, generated file layouts, and package APIs may change before general availability. Confirm you're on the latest EDK version before starting new projects.
</Warning>

EDK design starts with the work people need to complete, not with fields or page sections. Use the design workflow to define personas, stages, decisions, handoffs, and information hierarchy before implementing the experience.

You can complete the design work with Cursor, Claude Code, Cortex Code (CoCo), Claude Cowork, or another coding agent that supports Agent Skills. You do not need to write EDK code. The output is a design brief that a delivery team can review and implement later.

<CardGroup cols={2}>
  <Card title="Installation" icon="download" href="/edk/installation">
    Install the `elementum` CLI to access playbooks.
  </Card>

  <Card title="Playbooks" icon="book-open" href="/edk/playbooks">
    Learn how coding-agent playbooks work.
  </Card>
</CardGroup>

## Map the Process

Create a stage matrix for every materially different part of the process:

| Question        | What to define                                |
| --------------- | --------------------------------------------- |
| Persona         | Who is responsible at this stage?             |
| Primary job     | What single outcome must that person produce? |
| Decision        | What must they understand or decide?          |
| Required inputs | What must they review or edit now?            |
| Evidence        | What supports the decision?                   |
| Primary action  | What advances or closes the work?             |
| Failure path    | What blocks, rejects, or returns the work?    |

Two stages can usually share an experience pattern when they have the same persona, decision, required information, and action. Define a different experience when the person's job changes materially.

Keep distinct outcomes such as completed, rejected, cancelled, and retired. Combining them into a generic closed state removes information that reporting and Automations may need.

## Shape the Experience

For each distinct stage, decide what the responsible person needs to recognize, review or change, decide, and do next. Keep supporting evidence and history available without letting them distract from the current job.

The first view should answer three questions: What is this record? What matters now? What should I do next?

See [Record Experiences](/edk/guides/design) for the complete workshop.

## Use a Coding Agent

The design playbook uses the open Agent Skills format rather than a Cowork-specific format. You can use it before an EDK workspace exists. Install it in the standard project directory:

```bash theme={null}
elementum playbooks install --skill elementum-design --yes
elementum playbooks status elementum-design
```

Invoke `/elementum-design` and provide:

* The business outcome and process description.
* The people involved and their responsibilities.
* Current stages, decisions, handoffs, and failure paths.
* Existing screenshots, requirements, or user feedback.
* Current platform configuration when it is available.

Ask the agent to produce the stage matrix, record-experience recommendations, open questions, and a design brief. Make it explicit that the work should remain at the design level and that unsupported assumptions should be flagged.

### Cortex Code (CoCo)

CoCo supports Agent Skills in a project-level `.cortex/skills` directory. Copy the design playbook there:

```bash theme={null}
elementum playbooks install \
  --skill elementum-design \
  --copy-to ./.cortex/skills
```

In CoCo, run `/skill list` to confirm the playbook is available. Then ask CoCo to use `elementum-design` for the design task.

## Use Claude Cowork

Claude Cowork can run the design workshop before an EDK workspace exists. It is well suited to reviewing process documents, interview notes, screenshots, and requirements and turning them into a structured design brief.

Cowork loads skills enabled through your Claude account. It does not automatically load playbooks installed in a local `.agents/skills` directory.

<Steps>
  <Step title="Copy the design playbook">
    Copy only the design playbook into a temporary folder:

    ```bash theme={null}
    elementum playbooks install \
      --skill elementum-design \
      --copy-to ./cowork-skills
    ```
  </Step>

  <Step title="Package the skill">
    Create a ZIP with the `elementum-design` folder at its root:

    ```bash theme={null}
    cd cowork-skills
    zip -r elementum-design.zip elementum-design
    ```
  </Step>

  <Step title="Enable it in Claude">
    In Claude Desktop for Mac, open **Customize** → **Skills**, select **+** → **Create skill** → **Upload a skill**, upload `elementum-design.zip`, and enable the skill for your account.
  </Step>

  <Step title="Run the design workshop">
    Start a Cowork session, attach the relevant process material, and ask Claude to use `elementum-design`. Have it identify missing decisions and produce the stage matrix, information hierarchy, record-experience recommendations, open questions, and final design brief.
  </Step>
</Steps>

<Info>
  Cowork can produce and refine the complete design brief without an EDK workspace. A delivery team can use that brief to configure Elementum visually or implement it with the EDK.
</Info>

## Continue the Design

<CardGroup cols={2}>
  <Card title="Record Experiences" icon="layout-dashboard" href="/edk/guides/design">
    Define what each person sees and does.
  </Card>

  <Card title="Design Validation" icon="clipboard-check" href="/edk/design/validation">
    Review scenarios and confirm the design.
  </Card>
</CardGroup>