# Readiness Report Command

Evaluate your repository's agent readiness with the /readiness-report slash command.

The `/readiness-report` slash command evaluates your current repository against the Agent Readiness Model, scoring it across five readiness levels and providing actionable recommendations to improve.

---

## Prerequisites

- Run the command from inside a git repository with an `origin` remote configured (the repository URL is used to associate the report with your project in the Factory App).

---

## Usage

To use the command, navigate to the repo you'd like to evaluate and start Droid:

```bash
droid
```

Then enter the slash command:

```text
> /readiness-report
```

The evaluation runs against your current repo directory.

---

## What happens

When you run `/readiness-report`, the droid performs a comprehensive evaluation of the repository:

1. **Language Detection**: Identifies repository languages (JavaScript/TypeScript, Python, Rust, Go, Java, Ruby) based on configuration files and source code
2. **Sub-application Discovery**: Determines whether the repository is a mono-repo, or a single service/package/library. For mono-repos, this step identifies all independently deployable applications within the repo
3. **Criteria Evaluation**: Checks the criteria across all five readiness levels
4. **Report Storage**: Persists the evaluation results for visualization in the Factory App
5. **Summary Output**: Prints a human-readable report with results from the evaluation

---

## Understanding the output

After evaluation, `/readiness-report` prints a structured report with the repository's readiness level, discovered applications, criterion scores, and recommended next actions.

### Report sections

| Section | What it shows | Example |
| :------ | :------------ | :------ |
| Level achieved | Current repository readiness level from 1 to 5. | `Level 3: Standardized` |
| Applications discovered | Each independently deployable app or package found in a monorepo. | `apps/web - Main Next.js application` |
| Criteria results | Score and rationale for each evaluated criterion. | `Linter Configuration: 2/2 - ESLint configured in both applications` |
| Action items | Two to three highest-impact recommendations for reaching the next level. | `Add pre-commit hooks with husky to enforce linting and formatting` |

### Readiness levels

| Level | Name | Meaning |
| :---- | :--- | :------ |
| 1 | Functional | Basic tooling is in place. |
| 2 | Documented | Process and documentation are established. |
| 3 | Standardized | Security and observability are configured. |
| 4 | Optimized | Fast feedback and continuous measurement are in place. |
| 5 | Autonomous | Systems can improve themselves with agent support. |

Scores use `numerator/denominator`: the numerator is the number of sub-applications that pass the criterion, and the denominator is the number evaluated.

### Criterion difficulty

Each criterion also carries a **difficulty**: `Basic`, `Intermediate`, or `Advanced`. Difficulty is a separate axis from the readiness level: it reflects how much effort a criterion typically takes to satisfy, not which level it belongs to. When closing gaps, start with `Basic` criteria (the highest-leverage foundations every repository should have), then work through `Intermediate` and `Advanced`.

---

## Viewing historical reports

All readiness reports are automatically saved and can be viewed in the [web dashboard](/agent-readiness/dashboard). This allows you to:

- Track readiness progression over time
- Compare scores across repositories
- Share results with your team

<Tip>
  Run `/readiness-report` periodically (e.g., after major infrastructure changes) to track your organization's
  progress toward higher readiness levels.
</Tip>

---

## Remediation with `/readiness-fix`

Once you've generated a readiness report, the `/readiness-fix` slash command lets the droid automatically remediate the failing signals from the latest report. That turns the report from a diagnostic tool into an automated improvement workflow.

### What it does

`/readiness-fix` fetches the most recent stored readiness report for your repository and starts an agent session that works through the failing criteria, implementing fixes such as adding pre-commit hooks, creating an `AGENTS.md`, configuring CI checks, or improving documentation.

### Usage

Navigate to the same repository you ran `/readiness-report` against and start Droid:

```bash
droid
```

Then enter the slash command:

```text
> /readiness-fix
```

You can also pass additional natural-language instructions to focus the run:

```text
> /readiness-fix prioritize style & validation; do not touch CI configuration
```

### What to expect

1. **Report lookup**: The command resolves your repository from `git remote get-url origin` and fetches the latest readiness report stored for that repo.
2. **Agent session**: The droid plans and applies changes to address failing criteria, one at a time, just like a normal coding session. You can review and approve changes as they happen.
3. **Verification**: After fixes are applied, run `/readiness-report` again to re-score the repository and confirm signals have moved.

<Note>
  `/readiness-fix` requires that a readiness report has already been generated for the repo. If no prior report is found, run `/readiness-report` first.
</Note>

<Tip>
  Treat `/readiness-fix` like any other agent run: review the proposed changes, run your tests, and commit only what looks good for your codebase.
</Tip>

<RelatedLinks>
  <RelatedLink href='/agent-readiness/dashboard' title='Readiness Dashboard'>
    View and track readiness scores across your repositories.
  </RelatedLink>
  <RelatedLink href='/agent-readiness/overview' title='Agent Readiness'>
    Understand the five readiness levels and how scoring works.
  </RelatedLink>
</RelatedLinks>