# um-maybe

_A hallway check that asks: um, maybe you could just…_

> Source: https://fullstack.rocks/skills/um-maybe
> Code: https://github.com/Fullstack-Rocks/skills/tree/main/skills/um-maybe

You know the feeling. You pitch your plan in the hallway to a colleague who knows nothing about it, and their answer is “um, maybe you could just …”. Annoyingly, they’re usually right.

**um-maybe gives your agent that colleague.** A subagent on a **weaker model** sees the pitch and nothing else, and questions it. For each question the agent concedes, defends the piece with **proof** (something you asked for, quoted), or admits it can’t.

**Install**

Claude Code:

```shell
npx skills add Fullstack-Rocks/skills --skill um-maybe -a claude-code
```

Codex:

```shell
npx skills add Fullstack-Rocks/skills --skill um-maybe -a codex
```

Cursor:

```shell
npx skills add Fullstack-Rocks/skills --skill um-maybe -a cursor
```

Any agent:

```shell
npx skills add Fullstack-Rocks/skills --skill um-maybe
```

Prompt, to paste into your agent:

> Install the um-maybe skill from https://github.com/Fullstack-Rocks/skills by running npx skills add Fullstack-Rocks/skills --skill um-maybe, then run it on your plan before you implement it.

It also runs from inside `under-engineering`, so install it together with the other three under-engineering skills.

**Try saying**

- Plan a CSV export of the invoices in InvoiceList, then run the hallway check before writing code.
- Um-maybe this plan.

![Claude Code session: the agent plans a CSV export, runs a two-round hallway check with a lighter colleague agent, and sorts every piece into Simplified, Kept with proof and Unproven, asking only about the unproven ones](https://storage.googleapis.com/fullstack-rocks-media/skill-um-maybe-demo-poster.png)

_[▶ Watch the recording: claude · demo shop](https://storage.googleapis.com/fullstack-rocks-media/skill-um-maybe-demo.mp4) — A real Claude Code session on the demo shop, recorded as it happened. Long thinking stretches are sped up, everything else plays at its real pace._

Transcript:

```
> Plan a CSV export of the invoices in InvoiceList, then run the hallway check before writing code.
Skill(um-maybe): two hallway rounds with a colleague agent on a lighter model.
Simplified: the shared CSV module, full escaping, the extra id column and the shared download helper.
Kept, with proof: the export button, the invoices already loaded, the browser download.
Unproven: the header row, and how “paid” is written. Each comes with A) keep or B) a simpler option.
Does the simpler plan make sense to you? Once you’ve answered the two questions above, I’ll write the code.
```

## How does it work?

First, what counts as **proof**? Either something you asked for, quoted, or something you asked for that can’t work without it. “Best practice”, “future-proofing” and “it’s cleaner” are not proof.

1. **Write the pitch.** The problem in one sentence, what you asked for (quoted), and each planned piece with its reason. It stays under 15 lines with no file paths or code, and every extra is named: validation, retries, caching, config, abstraction layers, new modules.
2. **Hallway rounds.** A subagent on a weaker model gets the colleague prompt and the pitch, and nothing else. For each question the agent concedes, defends with proof, or says it can’t. Three rounds at most.
3. **Weigh each piece.** Every piece lands in exactly one group: Simplified, Kept (with proof), Unproven (with every simpler option and what it gives up) or Belongs elsewhere (infrastructure, legal, product or another team).
4. **Ask the human.** One message, and then it waits. The message holds only the unproven pieces, each with its options, and asks whether the simpler plan makes sense.

No subagents? Then the agent plays the colleague itself, using only the pitch, and tells you it did.

```mermaid
sequenceDiagram
  participant You
  participant Agent
  participant Colleague as Colleague (weaker model)
  You->>Agent: Plan a CSV export, then hallway-check it
  Agent->>Colleague: The pitch, and nothing else
  Colleague-->>Agent: Um, maybe you could just…
  Note over Agent: Simplified · Kept with proof · Unproven
  Agent->>You: Only the unproven questions
```

_The colleague sees only the pitch, and only the unproven pieces come back to you._

## But does it work?

**From the recording · Four of six planned pieces simplified**

In the recording, the shared CSV module turned into a few lines inline in InvoiceList.tsx, full escaping became a plain join (every field is a number or true/false), and the download helper shrank to about 4 lines in the click handler. Only two questions went to the developer: the header row, and true/false vs Yes/No.

![Six planned pieces of a CSV export after the hallway check: four simplified, one kept with proof, and one unproven, sent to the developer as a question.](https://storage.googleapis.com/fullstack-rocks-media/skill-um-maybe-proof.svg)

## The other skills

**The other skills**

- [under-engineering](https://fullstack.rocks/skills/under-engineering)
- [under-engineering-review](https://fullstack.rocks/skills/under-engineering-review)
- [call-depth](https://fullstack.rocks/skills/call-depth)
- [code-standards](https://fullstack.rocks/skills/code-standards)