# AI use cases for P3 Stack (uzairansaruzi/p3-stack)

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Use cases: 5 | Page: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/

p3-stack is a set of shell-installed agent skills that rebuild the pstack engineering workflow for T3 Code, using its delegation, worktree, PR watching, and scheduling features.

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

- Run a rigorous coding task through the p3 mode router: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/install-and-run-rigorous-task/
- Split a feature across child agents in separate worktrees: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/fan-out-work-to-worktree-workers/
- Get a thread woken when a PR checks, comments, or conflicts: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/wake-thread-on-pr-activity/
- Run audits on a schedule when no turn is active: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/schedule-recurring-repo-audits/
- Pull context from earlier threads instead of re-explaining: https://dedupedai.com/use-cases/uzairansaruzi-p3-stack/recall-prior-thread-context/

## How to run a rigorous coding task through the p3 mode router with P3 Stack

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Install the skills, map models once, then let p3-mode pick a playbook for a request.

**Who it is for:** A developer using T3 Code who wants agent work on a repo to follow a strict engineering process instead of ad hoc prompting.

**The problem:** Agent-written code often skips investigation and verification, which leads to slop that is hard to review.

**The outcome:** A working install, a models file in p3-models.md, and a task completed through a playbook chosen by p3-mode.

### Steps

1. Run `git clone https://github.com/uzairansaruzi/p3-stack.git` to fetch the repo.
2. Run `cd p3-stack` and then `./install.sh` to link the skills into ~/.agents/skills/.
3. In T3 Code, run `/setup-p3` so it maps each role to a provider and model you have, writing p3-models.md.
4. Run `/p3-mode` and describe your task; p3-mode picks a playbook and calls the other skills as needed.
5. Check the result against the verification the playbook ran before accepting the change.

### Prompt to paste into your agent

```text
In the repo at <repo-path>, use the p3-stack skills: run /setup-p3, then run /p3-mode on the task <task description>. Expected output: the code change plus the playbook steps taken. Verify that p3-models.md exists and lists a provider and model for each role.
```

### Caveat

The README lists the install and setup commands but does not show a sample run, so expect to read the playbook output to learn how it behaves on your repo.

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/uzairansaruzi-p3-stack/install-and-run-rigorous-task/

## How to split a feature across child agents in separate worktrees with P3 Stack

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Delegate parallel pieces to child agents, each bound to its own worktree and branch.

**Who it is for:** A developer with a feature large enough to split into independent parts that can be built at the same time.

**The problem:** Parallel agents editing one checkout collide, and advice alone does not stop two writers from touching the same files.

**The outcome:** Each piece lands on its own branch in its own worktree, with one writer per worktree enforced by the app.

### Steps

1. Install the skills with `./install.sh` from the P3 Stack clone, as described in the README.
2. Run `/p3-mode` and choose the orchestrate or multi-phase plan playbook for the feature.
3. Let the orchestrator call `t3_thread_launch` to start one worker per part, each in its own worktree and branch.
4. Let the orchestrator call `delegate_task` for review panels and sub-work, using the per-role models from p3-models.md.
5. Review each branch and merge the parts you accept.

### Prompt to paste into your agent

```text
In the repo at <repo-path>, use p3-stack's orchestrate playbook to split <feature description> into independent parts, one worktree per part via t3_thread_launch. Expected output: one branch per part and a short summary per branch. Verify that no two workers share a worktree.
```

### Caveat

The README does not describe how work is merged back, so merging and conflict handling are left to you.

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/uzairansaruzi-p3-stack/fan-out-work-to-worktree-workers/

## How to get a thread woken when a PR checks, comments, or conflicts with P3 Stack

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Difficulty: Intermediate | Time: 30 minutes | Basis: From the README

Watch an open pull request so the agent reacts to CI results and review comments.

**Who it is for:** A developer who opened a PR and wants the agent to act on checks and review feedback without polling.

**The problem:** Checking a PR by hand or running polling loops wastes time and misses changes.

**The outcome:** The thread wakes when checks finish, someone comments, or the branch conflicts, and the agent handles the event.

### Steps

1. Install the skills with `./install.sh` if you have not already.
2. Run `/p3-mode` and choose the opening a PR playbook for your branch.
3. Have the agent call `watch_pull_request` on the PR it opened.
4. When the thread wakes, read the check result or comment and let the agent respond.
5. Stop watching once the PR is merged or closed.

### Prompt to paste into your agent

```text
In the repo at <repo-path>, open a PR for branch <branch>, then call watch_pull_request on it. Expected output: the PR link and a note on each wake event (checks, comment, or conflict). Verify that the thread wakes on a real check completion rather than on a timer.
```

### Caveat

The README does not say which hosting services watch_pull_request supports, so confirm it works with your PR host before relying on it.

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/uzairansaruzi-p3-stack/wake-thread-on-pr-activity/

## How to run audits on a schedule when no turn is active with P3 Stack

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Difficulty: Advanced | Time: 45 minutes | Basis: From the README

Schedule repeated audit or overnight runs that fire without an open conversation.

**Who it is for:** A maintainer who wants regular checks on a repo, such as a nightly audit, without starting each run by hand.

**The problem:** Recurring audits get skipped when they depend on someone opening a session and typing a command.

**The outcome:** An audit runs on the cadence you set, and its results are available in the thread.

### Steps

1. Install the skills with `./install.sh` from the P3 Stack clone.
2. Run `/p3-mode` and pick the autonomous run playbook for the audit you want.
3. Have the agent call `schedule_task` with the audit prompt and the cadence you want.
4. Leave the schedule running; it fires even when no turn is active.
5. Read the thread output after each run and act on findings.

### Prompt to paste into your agent

```text
In the repo at <repo-path>, use schedule_task to run <audit description> on a <cadence> schedule. Expected output: a scheduled entry and a result in the thread after the first run. Verify that a run happens with no open turn.
```

### Caveat

The README does not list the cadence syntax schedule_task accepts, so check the tool's own input before writing your schedule.

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/uzairansaruzi-p3-stack/schedule-recurring-repo-audits/

## How to pull context from earlier threads instead of re-explaining with P3 Stack

Repo: [uzairansaruzi/p3-stack](https://github.com/uzairansaruzi/p3-stack) | Difficulty: Beginner | Time: 15 minutes | Basis: From the README

Search and read past T3 threads to recover decisions and code history.

**Who it is for:** A developer returning to a repo after days away who needs to know what was decided earlier.

**The problem:** Re-explaining past decisions to a new agent session costs time and loses detail.

**The outcome:** The agent finds the relevant earlier thread and summarizes the decisions it needs.

### Steps

1. Install the skills with `./install.sh` if needed.
2. Run `/p3-help` or `/recall` to find the right skill for a memory lookup.
3. Have the agent call `t3_thread_search` with keywords from the old work.
4. Have the agent call `t3_thread_read` on the matching thread.
5. Confirm the summary matches the thread before acting on it.

### Prompt to paste into your agent

```text
In the repo at <repo-path>, use t3_thread_search for <keywords>, then t3_thread_read on the best match. Expected output: a short summary of the decisions in that thread with thread identifiers. Verify the summary against the raw thread text.
```

### Caveat

The README names these tools without showing their inputs, so the search keywords you use may need trial and error.

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/uzairansaruzi-p3-stack/recall-prior-thread-context/