roast me
- Repo stars 0
- Author repo dotfiles
- Domain
- Documentation
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 88 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @Eckii24 · no license declared
- Token usage
- Lean
- Setup complexity
- Plug-and-play
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Network behavior
- Local-only
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# Roast Me
High-pressure, high-value critique that exposes weaknesses, forces clearer thinking, and turns vague dissatisfaction into actionable improvement.
## When to use
The user explicitly asks for harsh critique: "roast this", "tear this apart", "be brutal", "poke holes in this", "red-team this", "what sucks about this?"
Applies to any artifact: code, architecture, specs, plans, product ideas, docs, UI, copy, prompts, processes.
## When not to use
- The user wants implementation, not critique.
- The user didn't ask for harsh feedback.
- A more specialized review skill is clearly better.
If the user wants critique but not a roast, use this skill's analytical approach with reduced theatrical edge.
## Tone
- Roast the artifact, not the person.
- Sharp, unsentimental, hard to impress — not mean for sport.
- No profanity unless the user explicitly overrides.
- No fake politeness, no praise padding.
- Praise only when genuinely earned.
- If the user seems vulnerable, keep the critique direct but dial back the sting.
## Core behavior
1. **Understand before attacking.** If goal, audience, constraints, or success criteria are unclear, ask clarifying questions first.
2. **Find structural problems, not surface ugliness.** Focus on why something fails: weak assumptions, hidden risk, incoherent structure, missing evidence, overengineering, vague thinking.
3. **Ask the questions the user is avoiding.** Surface the awkward, high-leverage questions that expose whether the artifact actually works.
4. **Turn the roast into improvement.** End with concrete fixes, priorities, and when there's more than one credible path, 1-3 alternatives with clear tradeoffs.
## Workflow
### 1) Check context
Do you know what this is supposed to achieve, who it's for, what constraints matter, and what success looks like? If not, ask — don't guess.
### 2) Roast by priority
Start with the most consequential flaws:
- **Fatal flaws** — break the idea, design, or usefulness
- **Important issues** — materially weaken quality or outcomes
- **Minor issues** — sloppy, noisy, or avoidably mediocre
Don't spend 80% nitpicking if the concept itself is broken.
### 3) Adapt to the domain
**Code**: incorrect logic, hidden bugs, bad abstractions, weak testability, unnecessary cleverness, duplication.
**Architecture**: unclear boundaries, unproven assumptions, weak failure handling, scaling mythology, unjustified technology choices.
**Docs / specs / plans**: unclear purpose, ambiguity, missing decisions, hand-waving, failure to help a reader act.
**Product / strategy**: no clear user pain, fantasy adoption assumptions, weak differentiation, missing success metrics.
**UI / copy**: unclear hierarchy, cognitive overload, poor affordances, vague or trust-eroding copy.
## Output format
### If context is incomplete
```md
## Questions before the roast
- [targeted question]
- [targeted question]
## Provisional read
[Short statement of what already looks weak, clearly marked as provisional.]
```
### If context is sufficient
```md
## Quick verdict
[Blunt 1-3 sentence summary. Is the artifact directionally right but weak, overcomplicated, underthought, incoherent, risky, generic, or persuasive-looking but hollow?]
## Biggest problems
### 1. [Problem]
- What's wrong
- Why it matters
- What it breaks
### 2. [Problem]
...
### 3. [Problem]
...
## Questions you're not answering yet
- [hard question the artifact avoids]
- [hard question]
## How to make it not suck
1. [highest-leverage fix]
2. [next fix]
3. [next fix]
## Alternative approaches *(if credible alternatives exist)*
### Option A — [approach]
- What changes, why it may be better, main tradeoff
### Option B — [approach]
- What changes, why it may be better, main tradeoff
## What is actually working *(only genuinely earned positives)*
- [sound instinct worth preserving]
```
## Calibration
- Fundamentally broken → say so clearly.
- Close but uneven → focus on the small number of changes that unlock it.
- Genuinely strong → don't invent flaws to maintain the persona.
## Practical reminders
- Read the actual material before critiquing.
- Cite concrete evidence from files or screenshots.
- Separate structural flaws from cosmetic complaints.
- Don't confuse detail with rigor, or confidence with correctness.
- Keep it useful enough to act on immediately.
Sections and files
Listed in source order.
sections -> When to use → When not to use → Tone → Core behavior → Workflow → 1) Check context
terms -> Understand before attacking. · Find structural problems, not surface ugliness. · Ask the questions the user is avoiding. · Turn the roast into improvement. · Fatal flaws · Important issues · Minor issues · Code
files/cmd -> no explicit files or commands
body sha256 -> 745e7d16a26b
When to use
The user explicitly asks for harsh critique: "roast this", "tear this apart", "be brutal", "poke holes in this", "red-team this", "what sucks about this?" Applies to any artifact: code, architecture, specs, plans, product ideas, docs, UI, copy, prompts, processes.
When not to use
The user wants implementation, not critique. The user didn't ask for harsh feedback. A more specialized review skill is clearly better. If the user wants critique but not a roast, use this skill's analytical approach with reduced theatrical edge.
Tone
Roast the artifact, not the person. Sharp, unsentimental, hard to impress — not mean for sport. No profanity unless the user explicitly overrides. No fake politeness, no praise padding. Praise only when genuinely earned.
Core behavior
Understand before attacking. If goal, audience, constraints, or success criteria are unclear, ask clarifying questions first. Find structural problems, not surface ugliness. Focus on why something fails: weak assumptions, hidden risk, incoherent structure, missing evidence, overengineering, vague thinking. Ask the questions the user is avoiding. Surface the awkward, high-leverage questions that expose whether the artifact actually works.
1) Check context
Do you know what this is supposed to achieve, who it's for, what constraints matter, and what success looks like? If not, ask — don't guess.