opportunity-scan
Propose two or three pieces of work the user could own end to end, instead of threads to reply to. It starts from the metrics leadership watches (themes, OKRs, planning docs, meeting notes such as Gra
Файлы6
Открыть в GitHubSKILL.mdplugins/flagrare/skills/opportunity-scan/SKILL.md
GitHubOpportunity Scan
No em-dashes. Nothing this skill writes may contain an em-dash; use a comma, colon, or parentheses instead. Enforced by a repo hook. See
/flagrare:write-docs.
Plain words. In anything the user reads, use the plain names in
<plugin root>/lib/career/GLOSSARY.md("Senior behaviors", not "rubric rows"; "your written case", not "packet"; "the project you own", not "initiative"). The first time a term appears, say what it means in a few words and add the company's own word in parentheses when the user will hear it at work.
Impact-scan finds threads to weigh in on. The next level asks for more: finding a problem nobody assigned, and owning it through to a result someone can measure. This skill looks for those problems on purpose, checks nobody already owns them, and brings back two or three proposals the user could take to their manager.
The failure modes it must never enable:
- Grabbing someone else's work. A problem already owned is not an opportunity. The owner check runs before anything is proposed, and a proposal that skipped it is cut.
- Going around the people who decide. A proposal fits how the company makes decisions: if a PM drives the decision document, the first step feeds evidence into that document, never a competing one.
- Pitching on a guess. Every claim in a proposal has a link, or is marked as a check to run first.
- Spreading thin. At most one initiative is active, and it only counts as the user's after their manager agrees.
- Busywork dressed as a project. A fix that moves no metric the company watches, or that someone will do anyway, is not worth owning. Every proposal names the metric it moves, its baseline and a target, the way a product engineer frames a bet; anything that can't goes on a short "fixes worth mentioning" line instead.
This skill never posts, sends, or publishes anything. Sweeps are read-only, and the pitch is a draft for the user.
Library and state
Helper scripts live at <plugin root>/lib/career/, where the plugin root is two directories above this skill's base directory. Run them as python3 <plugin root>/lib/career/<script>.py .... They only read and print JSON. Write every state file with the Write tool, reading it first if it exists: a sandboxed shell cannot write under ~/.claude/skills.
initiatives.py context --home "$HOME" --today <YYYY-MM-DD>: everything the ranking reads (see step 1).initiatives.py propose --home "$HOME" --today <date> --id <slug> --title "<plain words>" --evidence <link> [--evidence <link> ...] --proposal '<json>': plansinitiatives.jsonwith a proposal.initiatives.py status --home "$HOME" --today <date> --id <slug> --status <status> [--aligned-with "<who>"] [--note "<why>"]: plans one status change.initiatives.py run --home "$HOME" --today <date>: plansopportunity-state.jsonwith this run's date.
A script that refuses (exit code 2) prints the reason; tell the user in plain words and do not work around it. The state files' shapes are in <plugin root>/lib/career/STATE.md.
Setup (every run)
- Load state. Run
python3 <plugin root>/lib/career/career_state.py plan --home "$HOME"and apply eachwriteaction with the Write tool, reading the target first if it exists. Never delete anything. - Config. Read
~/.claude/skills/flagrare/config.json. This skill sweeps the same surfaces as impact-scan and reuses its onboarding: surfaces, domains, target behaviors and audience come fromskills["impact-scan"](or the olderskills["senior-scan"]). If neither block hasonboarding_complete: true, run the onboarding in<plugin root>/skills/impact-scan/SKILL.md(identity, career target, domains, surfaces; skip voice and board if the user wants to move on) and save it underskills["impact-scan"]. This skill's own block,skills["opportunity-scan"], holdscadence_days(default 30) and, optionally,weightsfor the ranking (step 4).
Workflow
Called by /flagrare:career. When the arguments say this run comes from the career coordinator, run only when due, and end at the proposals digest without the closing question; the coordinator asks once at the end, and when the user answers about a proposal, record it with step 6. Before returning, in both interactive and scheduled runs, record every proposal that is not already in initiatives.json as a candidate with one sighting (python3 <plugin root>/lib/career/career_state.py candidate --home "$HOME" --id <slug> --title "<problem>" --evidence <its strongest link> --today <date> --details '<json>', where the details are the drafted problem, hypothesis, metric, baseline, target, lever, first_step, pitch, owner_check and the step 4 score, so the board can show and rank them while the user decides; reuse the id of a handed-off candidate or a dismissed problem instead of making a new one), so the proposals survive until the user decides, then run initiatives.py run and write opportunity-state.json with the Write tool so the cadence counts from today. When the arguments also say scheduled, never ask anything. Keeping, dismissing and activating always wait for the user.
1. Context and cadence
Anchor the clock first, exactly as /flagrare:impact-scan step 0 describes (or take now from the coordinator's arguments): every date in the proposals (a deadline, a planning cycle, "since" on evidence) is judged against it, and a change mentioned inside the window is new only if it happened inside the window.
Run initiatives.py context. It prints:
has_map, and from the promotion map:target(target_level,cycle,why,more_of,less_of),open_rows(rubric rows not yet done),unseen_people,decision_process(artifact,usual_driver), andpacket_deadline.more_ofandless_ofare lists by design; for the single-valued facts (target_level,cycle, thedecision_processfields,packet_deadline), a list means the map's sources disagree: show every option, never pick one.initiatives: theactiveone (or null),proposedandcandidates(each ranked: highest score first, unscored last, withrank{total, max, is_fix}) anddropped(each withseen_again: seen since it was dismissed).cadence:last_run,days_since,cadence_days,due,next_due, andwindow_start, the first day to sweep (the last run, or 30 days back the first time, never more than 90 days back).fallback: the impact-scan config'starget_behaviors,domainsandaudience.priorities: the company's themes and the metrics leadership watches, from the promotion map, each withmetric,baseline,target,owner_teamanduser_lever(ownerwhen the user's seat owns the metric's main input,inputwhen their systems feed it,nonewhen the lever sits in another team).
Cadence. When the user asked for this scan, run it even if it is not due. When /flagrare:career or a schedule started it and due is false, stop and say when it is next due (next_due).
Without a map the scan still runs. Ranking uses the configured target behaviors and domains; the "which open row" and "before the target cycle" factors are skipped; the first step defaults to bringing the problem to the manager. Say once, in the digest header, that /flagrare:promotion would sharpen the ranking.
With an active initiative, open the digest with a one-line check-in on it (what the last evidence shows, and whether it looks done). New proposals are still made, but none can become active until the current one is done or dropped.
1b. Metrics first (before the sweep)
Build the list of metrics this scan ranks against before looking at any finding, so impact decides the ranking instead of breaking ties.
- Start from
prioritiesin the context. - Add what the docs say leadership watches now: themes and strategy documents, OKRs, squad plans, launch posts with numbers. Search the docs surface for them first, before ranking; this search can run in the same message as the sweeps, but finish the list before step 4.
- Add what meeting notes say (when a meeting-notes surface is configured): priorities stated in planning meetings, all-hands and 1:1s with the user's manager.
For each metric, write one line: the metric, its baseline with a source (or Check first: and where the number lives), the team that owns it, and the user's lever from their seat (owner, input or none, judged from their domains and the systems they work in). Keep it to the five or six that matter most.
2. Sweep
Spawn one read-only sweep subagent per configured surface (including a meeting-notes surface such as Granola, when configured), all in the same message so they run concurrently, over window_start to today. Each gets its surface's scope, the domain map with keywords, the exclusions and the user's identity. Sweeps never post, react or comment.
Every sweep hunts the same five signals:
- Recurring pain: the same question asked again, repeat incidents with one cause, support toil, a manual step people keep doing by hand.
- Silent degradation: something getting slower, flakier or more expensive with nobody assigned (a flaky test everyone reruns, an alert everyone mutes, a metric trending the wrong way).
- Ownership gaps: a new integration or partner nobody supports, a team missing a skill it needs, work orphaned by a reorg or a departure.
- Unanswered invitations: "someone should look at this", "would love help with", a proposal waiting for a volunteer.
- Leadership priorities: themes documents, OKRs, planning docs, a new leader's stated focus. Search the docs surface for them; they tell you which problems will be noticed.
- Metric gaps: a metric from step 1b that is off target or unmeasured where the user's systems are an input (a partner-facing number nobody tracks, a funnel step that leaks, a complaint rate leadership quotes).
From meeting notes, take priorities, decisions and problems people raised; never quote what someone said about another person, and never surface private remarks.
Each finding comes back as: the problem in plain words, every evidence link, who is affected, who has talked about it, which metric from step 1b it touches (if any) and any number that sizes it, and any sign of an owner (an assignee, a ticket in progress, someone saying "I'm on it", a roadmap or planning doc that already schedules it).
Add the candidates from initiatives.json (the problems impact-scan handed off) to the findings, and any dropped item with seen_again: true, marked as dismissed before.
3. Owner check (hard filter)
For every finding, check whether someone already owns it before ranking it:
- search open tickets for the problem's keywords and linked incidents;
- search open PRs touching the systems involved;
- read the latest messages in the thread or channel where it was raised.
Record what you checked in one sentence (it becomes the proposal's owner_check). If someone owns it, or a roadmap or planning doc already schedules it (it will be done anyway), cut it and name the owner or the plan on the digest's Cut line; if the owner has gone quiet for weeks, it can stay, as "offer to help or take over", never as the user's own. A finding you could not check is cut too, with the reason.
4. Rank
Three more hard filters first:
- No metric: a finding that moves no metric from step 1b is not a proposal. If it is still worth fixing, it goes on the digest's "Fixes worth mentioning" line, one short line each.
- No lever: when the metric's lever sits in another team (
user_levernoneand nothing in the user's seat feeds it), it goes on the "Offer to help" line with the owning team, never as the user's own project. - Small or scheduled: a fix a teammate would do in their normal work this month, or one already on a plan, is cut with that reason.
Then score each survivor 0-2 on these factors (the key in parentheses is the name the score is stored under). Impact counts double, so the most is 18:
- Impact (
impact, x2): how much the metric would move, sized from a number with a source (orders, partners, revenue, a complaint rate). A guess with no number scores 0 and gets aCheck first:for where the number lives. Size it with/flagrare:measure-impact(before <the problem's strongest link> quick nosave called by /flagrare:opportunity-scan), only for findings that survived the hard filters, at most the top 3: its baseline, or its comparable scaled by the right base, with the confidence level, is the impact reason. A baseline it reports as unknown scores 0 here and carries itsCheck first:. Nothing is saved at this point. - Lever (
lever): the user's seat owns the input (2), feeds it (1). - Fit (
fit): it matches what the user wants more of, and is not something they want less of (with no map: their configured target behaviors). - Rubric (
rubric): it closes one of theopen_rows; pick the row fromopen_rowsonly, never invent one (no map: skip, score 1). - Who notices (
who_notices): people who would notice the result, with extra weight when they are inunseen_people(with no map: the configuredfallback.audience). - Standing (
standing): the user knows the area (one of their domains, systems they have worked in). - Evidence (
evidence): how often it came up and from how many places; a handed-off candidate withseen_count2 or more starts at 2. - Timing (
timing): it can show a result before thepacket_deadline(no map or no deadline: skip, score 1).
Write each score down with a one-line reason, as score in the proposal: {"impact": {"value": 2, "why": "about 300 partners a month ask where their money is"}, ...}. The reason names the number, person or link behind the value, so the user can argue with it. The library adds the total and sorts by it (rank in context: total, max, and is_fix when impact is 0), and the board shows the ranking with each reason. A user who weighs factors differently sets skills["opportunity-scan"].weights (whole numbers 1 to 3 per factor, for example {"fit": 2}), and the library applies them; never re-weigh by hand.
Drop anything scoring 0 on Impact, Standing or Evidence. Keep the top 3. Fewer than three good ones is a fine result: say so instead of padding with small fixes.
Rank the ones already waiting too. Candidates and earlier proposals without a score (the rank.total in context is null) get scored the same way in this run, so the board's ranking covers everything on the table. Record them with career_state.py candidate --details (a candidate) or propose (a kept proposal), adding the score and keeping every field already there.
5. Proposals
The digest is short: the user should know what each proposal is from its first line.
## Opportunity scan: <date>, window <window_start> to <today>. <caveats: surfaces skipped, no map, not due but run on request>
<one line on the active initiative, when there is one>
<Still on the table: each earlier `proposed` item, one line each with its title and when it was proposed, when there are any>
### 1. <the outcome, for whom: "Partners understand what they earned", not "Fix the payout page">, <total> of <max>
**Moves:** <metric> from <baseline, with its source> to <target> by <date, the written case's deadline when there is one>. **Your lever:** <what in your seat moves it>.
**Evidence:** <links, each with three words on what it shows>
**Owner check:** <what was searched, in one sentence, and who owns it, if anyone>
**The bet:** We believe <change> will <result> because <reason>. **Success:** <how the metric is measured, decided before building>. (<rubric row id>, only with a map)
**Rough impact:** <who gets what, in numbers where you have them>. **Who cares:** <people or teams, and why now>.
**First step:** <the smallest step, fitted to how decisions are made>
**Pitch for your manager:** <three sentences at most, in the user's voice>
(repeat, at most 3)
**Offer to help:** <finding: the owning team, and what you'd bring>; ...
**Fixes worth mentioning:** <small fix: one line>; ...
**Cut:** <finding: reason (owned by X, already planned, could not verify, no standing)>; ...
Rules:
- Fit the local decision process. When
decision_process.usual_driveris a PM or product role, the first step feeds evidence to them for theirartifact, and the pitch offers to own the engineering side. When it names engineering, the first step can be a short written proposal. Without a map, the first step is bringing it to the manager. - Nothing on an unchecked claim. Numbers and causes in a proposal come from a link. When one is missing, write
Check first:with the single check instead of the claim. - The hypothesis comes before the build. A proposal without a success metric is not ready: say what data would show it worked, and where that data lives.
- Scope to what the user controls. The target is the part of the metric the user's work can move. When a bigger change upstream decides the rest (a platform migration, another team's launch), say so and aim at what is reachable.
- Plain words. No ticket keys or channel ids in the headline; they go in the evidence links. Rubric row ids go in parentheses after the hypothesis, only with a map.
- Pitch in the user's voice. Read
~/.claude/skills/flagrare/career/voice.mdwhen it exists. First person, no preamble, no flourish.
Earlier proposals the user kept but has not started stay on the "Still on the table" line, not in the three new slots; ask whether any is now agreed with the manager or should be dropped.
Stop after the Cut line. Ask which proposals to keep, which to dismiss, and whether any is already agreed with their manager.
6. Record
After the user answers, write each change with the Write tool, one script call at a time (each reads the file the previous one wrote):
- Keep:
initiatives.py proposewith the fields below. Start from the candidate'sdraft_proposalwhen it has one, draft any required field it lacks (pitchandleveroften are), carry itsscoreover, and show the user the full proposal before recording it. For a handed-off candidate, reuse its id so its sightings carry over. For a problem the user dismissed before, compare this run's findings with thedroppedentries in step 2: when the user keeps one that has not been seen since it was dismissed, runstatus --status candidatefirst, thenpropose. - Dismiss: for an item already in
initiatives.json(a handed-off candidate, an earlier proposal, a dismissed problem seen again),initiatives.py status --status dropped --note "<why, in the user's words>"; it will not come back unless it is seen again. A new finding from this run that the user dismisses is simply not recorded (under the coordinator it was already recorded as a candidate, so dismiss it through the script like any other entry). A handed-off candidate the user neither keeps nor dismisses stays a candidate and comes back next run. - Agreed with the manager: keep it first (
propose, if it is not already proposed), theninitiatives.py status --status active --aligned-with "<who>" --note "<where or how it was agreed>". Only a proposal can become active, only one at a time, and never without the user saying their manager agreed. Do not suggest skipping that conversation. Then save its bet: run/flagrare:measure-impactwithbefore <the proposal's strongest evidence link> quick called by /flagrare:opportunity-scan, reusing the proposal'smetric,baselineandtarget, so the bet is followed after launch. Kept proposals are not saved, so the ones never started do not come back as bets waiting for a launch. - Finished or abandoned (when the user says so later):
--status doneor--status dropped. - Bring back a dismissed problem that has not been seen again (only when the user asks):
--status candidatefirst, thenpropose.
The --proposal JSON holds: problem, hypothesis, metric, impact, who_cares, why_now, first_step, pitch, owner_check, lever (what in the user's seat moves the metric), baseline, target, by, decision_fit (how the first step fits the decision process), score (step 4, checked by the script), and rubric_rows (ids from open_rows, empty without a map). The script refuses a proposal missing problem, hypothesis, metric, first_step, pitch, owner_check or lever.
Finally run initiatives.py run and write opportunity-state.json, even when nothing was kept, so the cadence counts from today. If a write fails, say so: the next scan would re-propose the same things.
When an initiative becomes active, suggest logging its milestones as contributions with /flagrare:impact-scan as they land; the contributions log stays the evidence trail.