agentleFS
MarvellbrazilMarvellbrazil/my-agentic-skills/skills/bring-me-ideas/SKILL.md

bring-me-ideas

Skill4 starsChanged 52 days agoMITView on GitHub

Researches a codebase and proposes ranked next-feature ideas, each answered in full 5W+1H form (what problem, who benefits, when it matters, where it lives in the code, why this approach, how it works) with evidence from the actual project. Use when the user types /bring-me-ideas, asks "what should we build next", wants feature suggestions, a roadmap, or product ideas grounded in the existing code. Read-only; proposes, never implements.

The file

We split this skill into the rules it gives an agent

4 rules. About 0 are common, 4 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈4

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Full 5W+1H: Every idea answers all six questions.

    line 19
  2. Distinctive:

    Evidence or omit: If you cannot point at the code that justifies an idea, it is a generic suggestion — drop it.

    line 25
  3. Distinctive:

    Run the high-signal ones:

    line 77
  4. Distinctive:

    Every idea gets all six. This is the deliverable's core, and it is where a generic suggestion becomes a proposal.

    line 134

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Bring Me Ideas

Propose the next features this project should build, and justify each one with evidence from the code itself.

What Makes This Not a Brainstorm

Anyone can list plausible features. "Add dark mode. Add search. Add notifications." That output is worthless because it is not grounded in the project — it would be identical for any codebase in the same category.

Four things make these ideas usable:

  1. Evidence. Each idea cites what in the codebase justifies it — a half-built feature, a TODO, a gap between two modules, a pattern that exists in one place and not another, an error path with no handling.
  2. Ranking. The ideas are ordered, with the ranking criteria stated. A flat list of twelve ideas is a way of refusing to make a decision.
  3. Full 5W+1H. Every idea answers all six questions. An idea missing "who" or "why this approach" is a wish, not a proposal.
  4. Honesty about cost. Each idea states its rough size and what it would put at risk. Ideas presented without cost get chosen blindly.

The Contract

  • Read-only. Propose. Do not implement, do not scaffold, do not open branches.
  • Evidence or omit. If you cannot point at the code that justifies an idea, it is a generic suggestion — drop it.
  • Say what you do not know. Product context, business goals, and user research are usually invisible in the code. Flag where an idea depends on information you do not have.
  • Do not pad. Five grounded ideas beat twenty generic ones. If only four are defensible, give four.

Phase 1 — Understand the Product

An idea is only good relative to what the project is and who it serves.

ls -a
cat README.md 2>/dev/null | head -80
cat package.json pyproject.toml composer.json go.mod 2>/dev/null | head -80

Establish:

QuestionSource
What is this product?README.md, marketing copy in the app
Who uses it?Routes, UI copy, role/permission models, seed data
What is the core loop?The main flow the app exists to serve
How mature is it?Test coverage, CI, number of TODO/FIXME, open issues
What is the domain?Schema, entity names, business rules

Also check whether a roadmap already exists — do not propose what is already planned.

find . -maxdepth 3 -iname 'ROADMAP*' -o -iname 'TODO*' -o -iname 'CHANGELOG*' \
  -o -iname '*.md' -path '*docs*' 2>/dev/null | head -20
git log --oneline -30

Phase 2 — Mine the Codebase for Signals

This is the step that separates this skill from a plain prompt. Each signal is a class of evidence that points at a real gap.

SignalCommandWhat it reveals
Unfinished workgrep -rn "TODO|FIXME|HACK|XXX" --include='*.ts' --include='*.py' .The authors already knew; the idea is half-decided
Stubbed codegrep -rn "not implemented|NotImplementedError|throw new Error('TODO|unimplemented" .A path that exists but does nothing
One-off patternsFind a capability implemented once and never generalizedThe abstraction that should exist
Missing counterpartsAn entity with create but no delete; a list with no search; a write with no auditThe obvious sibling feature
Error pathscatch blocks that only log; empty states; 500sResilience and UX gaps
AsymmetriesOne module has tests/validation/caching, a peer does notConsistency debt
Dependency hintsLibraries installed but barely usedCapability already paid for, not yet exploited
Scale risksUnbounded queries, missing pagination, N+1 patternsA feature that becomes necessary at volume
Config gapsHardcoded values that should be settingsOperational flexibility
Access gapsMissing roles, missing permissions, no audit logCompliance and safety features

Run the high-signal ones:

grep -rn "TODO\|FIXME\|HACK" --include='*.ts' --include='*.tsx' --include='*.py' \
  --include='*.php' --include='*.rb' --include='*.go' \
  . 2>/dev/null | grep -v node_modules | head -40
grep -rn "catch\|except\|rescue" --include='*.ts' --include='*.py' --include='*.rb' \
  . 2>/dev/null | grep -iE "console\.log|print|logger\.|# ?pass|=> \{\}" | head -25
git log --format='%s' -60 | sed 's/(.*//' | sed 's/:.*//' | sort | uniq -c | sort -rn

Also read the issues if the project has a tracker, and the largest files — the largest files are usually where the next feature will be hardest.

wc -l $(git ls-files '*.ts' '*.tsx' '*.py' '*.php' 2>/dev/null | head -60) 2>/dev/null | sort -rn | head -12

Phase 3 — Generate and Filter

Generate more candidates than you will present, then filter hard.

A candidate survives only if it passes all four gates:

  1. Evidence gate. You can cite the file, line, or pattern that justifies it. No citation, no idea.
  2. Fit gate. It serves the product's core loop or a user the project already has. Features for users who do not exist are speculation.
  3. Non-duplication gate. It is not already implemented, already planned, or already in the issue tracker.
  4. Value gate. You can state the concrete outcome — what becomes possible, or what stops hurting.

Kill on sight:

  • Generic platform features unrelated to this product ("add i18n" to a single-locale internal tool).
  • Anything requiring a business decision you have no information for ("add a paid tier").
  • Rewrites dressed as features ("migrate to microservices").
  • Ideas that only add surface area with no user-visible outcome.

Phase 4 — Rank

Rank with stated criteria, not vibes. Use this table and score honestly.

CriterionWeightQuestion
Evidence strengthHighIs the gap visible in the code, or inferred?
User impactHighHow much does it improve the core loop?
EffortMediumDays, not weeks? Or a multi-week project?
RiskMediumDoes it touch auth, money, or data migration?
DependencyLowDoes it unblock other ideas?

Rank by (evidence × impact) ÷ effort, and break ties toward lower risk. Then present in rank order and say the criteria out loud so the user can re-rank with their own knowledge.

Phase 5 — Write Each Idea in 5W+1H

Every idea gets all six. This is the deliverable's core, and it is where a generic suggestion becomes a proposal.

### 1. <Idea title>

**What is the problem**
The concrete problem, grounded in the code. Cite the evidence.

**Who is the target**
Which user or role benefits. Name them from the project's own vocabulary — the roles in
the permission model, not "users" in the abstract.

**When is it useful**
The moment in the workflow where this matters. "When an admin onboards a new tenant and
must create 40 projects by hand."

**Where to implement**
The exact files and modules. Entry point, service layer, schema, UI surface.

**Why this solution**
Why this approach over the alternatives. Name at least one alternative and why it loses.

**How it works**
The mechanism, end to end, in a few steps. Enough that an engineer could estimate it.

---

**Evidence** `src/orders/service.ts:88` — bulk create exists, single create does not
**Effort** ~2 days
**Risk** Low — additive, no schema change
**Depends on** Nothing

Worked example

### 1. Bulk project import for tenant onboarding

**What is the problem**
Admins can create projects one at a time only. The onboarding flow
(`src/onboarding/wizard.tsx:44`) loops over a single-create call, so a 40-project
tenant takes 40 round trips and fails halfway with no recovery. The API already
exposes a bulk path for orders (`src/api/orders.ts:112`); projects have no equivalent.

**Who is the target**
Tenant administrators — the `admin` role in `src/auth/roles.ts:8`. They onboard
customers and are the only role with `project:create`.

**When is it useful**
During tenant onboarding, and during quarterly restructures when an org re-plans
its project hierarchy. Both are currently done by hand.

**Where to implement**

- `src/api/projects.ts` — add `POST /projects/bulk`, mirroring `orders.ts:112`
- `src/onboarding/wizard.tsx:44` — replace the loop with one call
- `src/db/schema.ts` — no change; reuse the existing `projects` table
- `tests/api/projects.test.ts` — new cases

**Why this solution**
A bulk endpoint rather than a client-side parallel loop. A parallel loop still
leaves partial state on failure and multiplies load; one transactional bulk call
is atomic and matches the existing orders precedent. The alternative — a background
job with a progress UI — is more correct at 10k rows but overbuilt for the observed
40-row case, and can be added later behind the same endpoint.

**How it works**

1. `POST /projects/bulk` accepts `{ tenantId, projects: [...] }`, validated by the
   existing Zod schema from `src/api/schemas.ts`.
2. The handler opens one transaction and inserts all rows via `db.insert(projects).values([...])`.
3. On any constraint violation the transaction rolls back and returns the offending
   index, so the wizard can highlight the bad row.
4. The wizard submits one request and shows a single success or failure.

---

**Evidence** `src/onboarding/wizard.tsx:44` (serial loop), `src/api/orders.ts:112` (bulk precedent)
**Effort** ~2 days
**Risk** Low — additive endpoint, no schema change
**Depends on** Nothing

Output Shape

# Next Feature Ideas — <project name>

<2-3 sentences on what the project is and what the core loop is, so the ranking has context.>

## How These Were Ranked

Evidence strength × user impact ÷ effort, ties broken toward lower risk.

## Ideas

### 1. <highest ranked>

<full 5W+1H>

### 2. <second>

<full 5W+1H>

...

## Considered and Rejected

| Idea      | Why rejected                                                          |
| --------- | --------------------------------------------------------------------- |
| Dark mode | No evidence of demand; the app has no theming layer and one user role |

## Open Questions

- <what you could not determine from the code that would change the ranking>

The Considered and Rejected section is not filler. It shows the user the search space was wider than the output, and it often contains the idea they actually want.

Common Mistakes

MistakeWhy It BreaksCorrect Approach
Generic feature listsIdentical for any project in the category; no valueCite code evidence for every idea
No rankingA flat list refuses to make a decisionRank with stated criteria
Missing 5W+1H fieldsThe idea is a wish, not a proposalAll six, every idea
"Users" as the targetSays nothing about who benefitsName the project's real roles
No effort estimateThe user cannot sequence the workRough size, in days
Hiding riskAuth, money, and migrations get chosen blindState what the idea puts at risk
Proposing what is already plannedWastes the user's attentionRead the roadmap, TODOs, and issue tracker first
Rewrites disguised as features"Migrate to microservices" is not a featureOnly user-visible outcomes
Implementing instead of proposingAnswers a different questionRead-only
Padding to a round numberDilutes the good ideasFour strong ideas beat twelve weak ones
Ignoring the codebase's own vocabularyThe proposal does not read like it belongsUse the project's entity and role names
No rejected sectionHides the search spaceList what you considered and why it lost
Claiming business knowledge you lackConfident proposals built on invented contextFlag what depends on information you do not have

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.