# AI use cases for Hyperfide (Sidiora-Labs/hyperfide)

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Use cases: 6 | Page: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/

Hyperfide is a local agent workflow CLI that indexes a code repository into a graph, runs planned task loops, and keeps decisions and release notes for humans and AI agents.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Turn a feature idea into a verified task plan: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/plan-and-verify-a-feature-spec/
- Give an agent a compact brief of a code area: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/brief-an-agent-on-a-code-area/
- Fan a task wave out to parallel Codex or Claude Code sessions: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/run-a-wave-with-parallel-agents/
- Run a supervised agent fleet across a spec hierarchy: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/supervise-a-spec-hierarchy-with-a-fleet/
- Generate release notes from git history: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/write-release-notes-from-git-history/
- Save project decisions so the next session recalls them: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/carry-decisions-across-agent-sessions/

## How to turn a feature idea into a verified task plan with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Create a spec, lint it, and mark tasks done only after the graph and history agree.

**Who it is for:** A developer starting a new feature who wants the agent's plan checked against the real codebase before work begins.

**The problem:** Task lists describe intent but do not prove the code matches the plan, so tasks get marked complete without evidence.

**The outcome:** A spec with a task board, dependency waves, and acceptance criteria, where each done status is checked against the code graph.

### Steps

1. Run `hyperfide spec new` to create the plan for the feature.
2. Run `hyperfide spec add` to add tasks, declaring the paths each task touches.
3. Run `hyperfide spec lint` to confirm the plan is executable.
4. Run `hyperfide spec next` to see the next task to work on.
5. Run `hyperfide spec done` after the work is finished; it refuses completion if the graph and history do not match the declared task.

### Prompt to paste into your agent

```text
In the Hyperfide repository at <repo path>, create a spec for <feature name> using `hyperfide spec new` and `hyperfide spec add`, then run `hyperfide spec lint`. Report the task list with dependency waves and any lint errors. Verify that every task lists the paths it touches.
```

### Caveat

The README says the spec loop runs against the indexed graph, so the plan is only as accurate as the code Hyperfide has indexed.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/plan-and-verify-a-feature-spec/

## How to give an agent a compact brief of a code area with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Pull matching symbols, callers, callees, and routes into one budgeted context call.

**Who it is for:** A developer or reviewer about to change unfamiliar code who wants a fast, bounded summary before editing.

**The problem:** Agents wander a repository file by file, which costs time and tokens and still misses who depends on the code.

**The outcome:** One context packet with ranked symbols, snippets, callers, callees, related routes, and an explicit count of anything cut by the budget.

### Steps

1. Run `hyperfide context` followed by the symbol or area name you plan to change.
2. Read the returned symbols, callers, and callees before editing.
3. Run `hyperfide changes` to see the blast radius of your uncommitted edits.
4. Run `hyperfide guard` to check whether an edit drifts outside the declared scope.

### Prompt to paste into your agent

```text
In the Hyperfide repository, run `hyperfide context` on <symbol or area> and summarize the matching symbols, callers, and callees. Then run `hyperfide changes` and list the affected symbols. Verify that any omitted items are reported as omitted, not silently dropped.
```

### Caveat

The README describes the context command's default budget of 4000 tokens, and language coverage varies by family, so check the coverage matrix for your language.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/brief-an-agent-on-a-code-area/

## How to fan a task wave out to parallel Codex or Claude Code sessions with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Advanced | Time: 1 hour 30 minutes | Basis: From the README

Claim conflict-free tasks and run each in its own sandboxed agent process.

**Who it is for:** A team lead with a spec wave of independent tasks who wants several coding agents working at once without path collisions.

**The problem:** Running several agents on one codebase risks overlapping edits, and tracking who holds which task is manual.

**The outcome:** Each claimed task runs in one sandboxed child process, with logs and prompts saved on disk and leases released on failure.

### Steps

1. Run `hyperfide spec lint` to confirm the wave is executable.
2. Run `hyperfide spec claim-next` so an idle agent takes the next conflict-free task.
3. Run `hyperfide spec run` to fan the whole wave out to Codex CLI or Claude Code sessions.
4. Check the logs and prompts saved on disk for each claimed task.
5. Run `hyperfide spec done` on each task only after its evidence checks pass.

### Prompt to paste into your agent

```text
In the Hyperfide repository, run `hyperfide spec run` for wave <wave number> using Codex CLI or Claude Code. Report each claimed task, its log location, and its final status. Verify that no two tasks declare overlapping paths before the run starts.
```

### Caveat

The README says parallel work is bounded by the disjointness of declared paths, so tasks with undeclared or overlapping paths can still collide.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/run-a-wave-with-parallel-agents/

## How to run a supervised agent fleet across a spec hierarchy with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Advanced | Time: 2 hours | Basis: From the README

Start a detached supervisor that drives every wave, manager, and worker until work merges.

**Who it is for:** An engineering lead running a large spec with a main agent, wave managers, and task workers who wants unattended progress with approval gates.

**The problem:** Large multi-branch work needs constant nudging, retries, and merge checks that are hard to run by hand.

**The outcome:** A durable supervisor that retries failed agents, escalates what cannot be rescued, and reports complete only when work has merged.

### Steps

1. Run `hyperfide fleet up` to start the detached supervisor for the spec hierarchy.
2. Check progress through `hyperfide events --follow` or `hyperfide serve` in your editor.
3. Run `hyperfide fleet up --resume` after a supervisor crash to adopt agents still alive.
4. Run `hyperfide fleet down` to stop the supervisor when the run is finished.

### Prompt to paste into your agent

```text
In the Hyperfide repository, start the fleet with `hyperfide fleet up` and follow `hyperfide events --follow` for <N> minutes. Report which waves merged, which tasks were escalated, and whether any approval gate is waiting. Verify that completion is reported only for merged work.
```

### Caveat

The README says the supervisor runs only after fleet up and the pull request and checkpoint steps call gh, so the gh CLI must be set up for those steps.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/supervise-a-spec-hierarchy-with-a-fleet/

## How to generate release notes from git history with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Build a changelog grouped by commit prefix, with optional model-written highlights.

**Who it is for:** A maintainer preparing a release who wants accurate notes without rereading every commit.

**The problem:** Release notes are slow to write by hand and easy to miss tasks, especially across many tagged versions.

**The outcome:** A changelog with one release per tag or version bump, grouped by commit-subject prefix, with task references carried through.

### Steps

1. Run `hyperfide changelog` in the repository to write release notes from git history.
2. Review the grouped sections and the task references carried through.
3. Add the key only if you want the optional model-written Highlights paragraph for each release.

### Prompt to paste into your agent

```text
In the Hyperfide repository, run `hyperfide changelog` and report the number of releases and the groups used. Verify that each task reference from the commit history appears in the output.
```

### Caveat

The README says the default changelog comes from git history, and a project with no git needs the --snapshots option instead.

Risk, credentials: The optional Highlights paragraph needs CENTRA_API_KEY or HYPERFIDE_CHANGELOG_KEY, so store that key in your environment and never commit it to the repository.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/write-release-notes-from-git-history/

## How to save project decisions so the next session recalls them with Hyperfide

Repo: [Sidiora-Labs/hyperfide](https://github.com/Sidiora-Labs/hyperfide) | Difficulty: Beginner | Time: 30 minutes | Basis: From the README

Store decisions and constraints in project memory and recall them at session start.

**Who it is for:** A developer whose agent keeps rediscovering the same constraints because each session starts with an empty context window.

**The problem:** Context windows reset, so agents repeat the same investigation and reach decisions already made.

**The outcome:** Decisions saved once and surfaced automatically on the next task start, with blocked completions recorded as well.

### Steps

1. Run `hyperfide remember` mid-task to save a decision, constraint, or outcome.
2. Run `hyperfide recall` at the start of the next session to bring relevant notes back.
3. Run `hyperfide spec trace` on a task to see its symbols, commits, and memories together.

### Prompt to paste into your agent

```text
In the Hyperfide repository, save the decision <decision text> with `hyperfide remember`, then run `hyperfide recall` for <topic>. Report which notes were returned and their order. Verify that the saved note appears in the recall output.
```

### Caveat

The README says memory lives in the same local database as the graph, so it only applies to the repository where Hyperfide is set up.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sidiora-labs-hyperfide/carry-decisions-across-agent-sessions/