CommunityCoding & Developmentgithub.com

maybe-im-smart

Unblocks repetitive iterations that don’t converge: this skill doesn’t offer better ideas but points where to look for a different practice; the other half audits existing cross-domain correspondences (judges structure, not truth). For stuck/deadlock/impasse/blocked self-checks. Yes, even if no one says so: a path has regressed twice; three rounds of revisions where each next step is just the direct consequence of the last failure; ≥3 rounds of back-and-forth Q&A on the same goal without resolution; the AI’s substantive reply makes the user pick among candidates; none of the candidates the AI raises are new to the user. Audit trigger: an existing cross-domain analogy/correspondence needs to be judged for structural self-consistency before entering a reasoning chain or being transferred. Not for: topic brainstorming without a sticking point, when the next step is known but unwelcome (execution problem), missing facts (look them up), missing constraints (ask precisely), judging analogy truth (audit only handles structure), or polishing/explanation.

What is maybe-im-smart?

The `maybe-im-smart` skill is a specialized tool designed for AI agents (e.g., Claude Code, Cursor, Codex) to break out of deadlock loops where a task iterates without converging. It doesn't generate better ideas; instead, it systematically shifts the search space from "what to do" (action) to "where to look" (a different practice or domain). The skill has two halves: (1) a structured procedure for unblocking—decomposing the problem, stripping domain-specific terms, retrieving alternative practices (first within the home domain, then cross-domain), and landing them as actionable steps—and (2) an audit function (`references/audit.md`) that checks the structural self-consistency of an existing cross-domain correspondence before it's used in reasoning. It is triggered only when specific external or AI-side signals indicate genuine stuckness (e.g., ≥3 rounds of fruitless Q&A, AI making users pick from stale candidates). The markdown includes detailed classification tables (7 task types), decomposition columns (keep/block/stuck/constraints), a retrieval pipeline (2a direction generation → 2b verification → 2c gap filling), and CLI tools (`maybe_smart.py`) with gates for recording and landing. This ensures the agent doesn't waste turns on non-stuck scenarios and provides a rigorous, reproducible method for breaking out of local optima.

Works with~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/benbird316/maybe-im-smart/tree/HEAD

Installed? Explore more Coding & Development skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Ask in your favorite AI

Open a new chat with this agent skill pre-loaded.

Documentation

maybe-im-smart — keep the goal, look somewhere else for an existing practice

The output is an action — the actor, the first step this week, how to know it worked. Not an idea.

Criterion: once loaded, whether to proceed

Loads only when a trigger in description is hit. After loading, pass the first gate: the next step must be out of sight — hard does not count, only no candidate counts. Then the second gate: what is missing — only the first category goes through this procedure:

What is missingWhere to goBoundary
Missing action (what should be done)This procedureOnly this category needs to look somewhere else for a practice
Missing fact (what it is)Look it upAsking the user about what the AI can look up wastes the user's time
Missing constraint (what must not be moved)Ask, and ask preciselyOnly ask "what must not be moved"; asking "how to do it" hands the action space back

Several other cases do not belong here. The next step is known and merely unwanted = an execution problem. A deadlock in the technical sense (threads waiting on each other, tool-call loops, retry storms) = a bug to fix, not the "the user repeatedly asks the AI, the AI repeatedly asks the user" back-and-forth; that back-and-forth is the "≥3 rounds of back-and-forth Q&A" category. Topic brainstorming with no sticking point = just ask for ideas. Polishing and explaining = no retrieval domain to switch to.

The other half is audit, which skips the judgement and announcement above. To judge an existing cross-domain correspondence for structural self-consistency (before it enters a reasoning chain, or before its mechanism is carried back to domain A), read references/audit.md directly; structure only, not whether the analogy is true.

Self-check: no need to wait for the user to speak

The external-event signals are countable from the record. The signals below are AI-side only and only the AI can admit them:

  • The substantive action of the AI's current reply is making the user pick among candidates (asking for a choice, not a fact)
  • Among the candidates the AI is about to raise, not one is something the user did not raise

If either holds, that counts as stuck, and the two gates "next step out of sight" and "what is missing is an action" no longer need to be met.

When the judgement holds, announce the trigger so the user can reject or downgrade it on the spot:

— run a round with maybe-im-smart, in three steps: decomposition, retrieval, landing (references/probe.md).

Copy verbatim from the hit entry in description, or from the sentence the AI admitted; do not rewrite it as a summary.

If it does not hold, do not say a word.

1. Classify the task type

TypeShape of the sticking pointExample
DetectionMust discover whether something exists or does not exist; misses or false hitsReview still misses
BlockingMust stop something from happeningThe same incident recurs
AllocationLimited resources split among several needsSchedule conflicts, budget splitting
CoordinationActions of multiple parties must stay consistentHandover distortion, cross-team consensus
TimingOrder or pace goes wrongDependency inversion, feedback delay
ContinuityThe system must not collapse under disturbanceCapacity maxed out, key people leaving
DecisionMust conclude while information is incompleteWhether to release with insufficient evidence

If none fits, invent a name. This table only forces out "what shape of problem is this".

2. Decomposition: four columns

ColumnWhat it asksExample (missed defects in code review)
keep what must be keptWhat keeps it running now? Move it and everything collapsesAn independent judgement before merging
block what must be blockedWhich failure is happening?There is a judgement but it does not act as one
stuck where it is stuckOne sentence "want X, but lack Y"Raise the detection rate, but adding people lowers it
constraints what must not be movedWrite the one constraint actually hitCannot add staff; cannot extend the schedule

Beyond the four columns, keep the domain-A operation table ops_A — name: input → output, objects under their real names. The landing gate uses it for subject (in domain A?) and action (an old action renamed?).

Decomposition failed = the sticking point is not located yet; go back and locate it. If stuck cannot be written as "want X, but lack Y", do not go further.

3. De-cued restatement

Ask two questions repeatedly until both fail: does this name hint at the use? Can it be broken down further? Method, criteria and examples: stage one of references/probe.md.

Produce:

  • one neutral restatement (≤40 characters, containing no domain-specific terms of the home domain)
  • 3–5 search terms (neutral nouns or verbs)

A home-domain term in the search terms means the step is not done. List those terms in domain_terms; the tool blocks by substring matching.

4. Retrieval (2a direction generation → 2b verification against primary sources → 2c gap filling)

Scan the home domain first, then leave it. First thing in 2a.

"Source" here does not mean "another field". A source has two granularities:

What is changedThe source isMechanism
Branch switchAnother branch inside domain AReplaces the premise of the main line, not a mapping
Cross-domain switchAnother fieldStructural mapping φ: A→B

Two kinds of "another branch", both counting: one squeezed out by peers (done before, abandoned later); one never used as a method at all — something that already holds in the home domain (a mandatory field in a documentation standard, an existing index structure, a rough workaround another team uses), only no one has applied it to this problem. The second is not invention: it must already exist in the home domain; only its position changes.

b_domain records the actual source: for a branch switch, the name of domain A plus the branch name; for a cross-domain switch, that field. Only a namable specific source counts.

"The home domain is exhausted" is undecidable; do not judge it. Check two tables, one record each:

What is scannedHow to scanWhat to record
Shared premiseSee "how to break a premise" below, five stepsOne premise + one practice that rejects the premise, or "no such practice in the home domain"
Untaken branchAsk about both kinds. ① The home domain's one-time mainstream practice is now abandoned — was it refuted, or merely out of fashion? ② Why has something that already holds in the home domain never been used as a method?Branch name + why it was not taken; if none, write "no such branch in the home domain"

How to break a premise — the scan for the "shared premise" table. Five steps, none skipped:

  1. Put the failed paths side by side; write their shared premise as one sentence that can be negated — if it cannot, the premise is not yet stated.
  2. Break it into clauses that can be negated individually.
  3. For each clause: is there a home-domain practice that does not take it as a premise? If yes, fill it in; that clause is scanned.
  4. The clause answering "no" everywhere is the direction to leave.
  5. Use the negation of this clause as the search terms. Not a discipline name — a discipline name returns only keyword papers from that discipline, and the search loops right back to the start.

confidence does not count when breaking premises.

Only when both tables answer "none" is leaving permitted. "Empty" means no counter-example practice, not no words. A line reading "no such practice in the home domain" also counts as empty.

A branch switch is not just thinking again. One criterion: the new branch does not take the failed paths' shared premise. More effort, finer detail, parameter tuning under the same premise only carry the main line further. Cannot name it: the branch is not found yet.

The two tables scan places the main line has not walked, not the main line itself. Open-ended problems get the same treatment: avoid the home domain's clichés, not the home domain.

Home-domain entries go into recall on equal footing with cross-domain entries: structure states "which home-domain branch, and which one is being taken now". Leaving is admitted by step three's two outputs: zero domain-A terms in restated (not checked by the tool — count it) and no domain_terms term in terms (blocked by the tool). The tool does not check the two tables.

The three sub-steps all belong to stage two and run in order within one round. Do not merge them into one query — merged, 2c becomes a continuation of 2a.

StepActionOutputHard formatWhat it can prove
2a direction generationFrom parametric memory: where might a practice be (home-domain untaken branches first)A direction + "what might be there"origin: "recall", confidence, lens operator; 3-6 entries, ≥2 lenses; status always unverifiedOnly "seen this area", not that the practice exists there
2b verification against primary sourcesCheck each entry against an external primary source: does that practice exist there?verified / refuted / unverified (checked but undecidable stays unverified)verified must carry a provenance; refuted must carry a correctionTurns guesses into citable facts
2c gap fillingChange the search terms and search again, for directions 2a never thought ofNew sourcesorigin: "search" and status per entry; each result records queryPast the training-data boundary

2c returning the same practice as 2a (same domain, same practice) = the step did not leave; that is a continuation, not gap filling. Another practice in the same domain counts — but "other" must go into structure, or it cannot be told from the 2a entry in the record, and the tool cannot judge duplication either. The tool does not check this; count it.

For prompts and order, see references/probe.md. Do not compute recall accuracy: 2a gives directions, not propositions.

The four framing lenses (used for 2a direction generation, re-checked against candidates at the landing gate)

In 2a, tag each direction with one lens; 3-6 entries cover ≥2. Four entries from one lens are four copies of one analogy, right and wrong together — check divergence at 2a, not at the landing gate at the end.

The lens asks "where", not "how far". The answer can be another branch of the home domain or another field.

Framing lensAsk with it
function(功能)In which field is this verb (detection / buffering / rate limiting / calibration) a standard component?
conflict(矛盾)Who treats "want X and at the same time not X" as everyday business?
scale(尺度)How do fields one notch down (a single occurrence) and one notch up (an organization, an ecosystem) do the same thing?
failure(失败)Which field has a written incident archive handling this kind of failure?

5. Back-translation: land as domain-A actions

Back-translate each practice on the source side; drop what is untranslatable back.

Write why first; if it cannot be written, drop the entry. Not appended after the other columns — by then keeping is already decided, and what gets written is a justification found for it. why is the admission gate: the A side quotes the exact words of decompose.stuck; the B side states what does the work in that field. B-side only ("that field works well this way") spins; A-side only restates the sticking point; the two not lining up = untranslatable back.

For evidence, choose one: the provenance of the source practice, or inferred. Marking inferred is allowed; writing an inference as a provenance is not. It governs the fact (the practice exists there); why governs the correspondence (same spot as the domain-A sticking point?).

The tool only checks that why is non-empty; it cannot tell whether it was written first or appended afterwards. Soft, like the 2c self-check: blocks the obviously undone.

6. The two gates and the commands

python3 scripts/maybe_smart.py --recall decompose.json           # record gate
python3 scripts/maybe_smart.py --check cands.json decompose.json # landing gate
python3 scripts/maybe_smart.py analogy.json                      # audit (optional)

--quiet is an output switch, not a mode slot: by default the full report is printed; with it, only the result line (PASS / FAIL; --check processes one pair and prints a single line). Exit codes: 0 pass / 1 block / 2 input error.

Record gate: task_type non-empty and all four columns present; restated ≤40 characters; terms ≥3 with no domain_terms term (if domain_terms is not listed, this gate cannot be checked and counts as not passed); every recall entry has a non-empty b_domain; ≥3 recall entries; same source, same practice does not repeat (two different practices under one branch count as two); status takes only verified / refuted / unverified; verified carries source, refuted carries correction; at least 1 entry with origin as search and a recorded query.

Landing gate, seven checks:

  1. Six fields non-empty: operator / action / subject / first_step / observable / why
  2. ≥2 framing lenses; operator may take only the Chinese literals 功能 / 矛盾 / 尺度 / 失败 (function / conflict / scale / failure); any other value is non-conforming
  3. subject is within ops_A names
  4. action is within ops_A inputs/outputs (i.e., the action already exists in domain-A naming)
  5. first_step is a single Monday-morning executable step (not a direction)
  6. observable is a concrete, checkable fact (not an abstraction)
  7. Evidence: if evidence is not inferred, it must match a source string from record gate output — or a user-supplied paper / document / thread
    • If unmatched, the landing gate treats the entry as inferred without warning

Blocks on the first unqualified entry; does not report the rest.

7. Appendices

A. References

  • references/probe.md — step-by-step prompting for stages one and two
  • references/audit.md — audit-only structural self-consistency check

B. Full example: code review defect misses (home domain = software engineering)

StepOutput
ClassificationDetection
decompose.keepIndependent judgement before merging
decompose.blockThere is a judgement but it does not act as one
decompose.stuckWant to raise detection rate, but adding people lowers it
decompose.constraintsCannot add staff; cannot extend schedule
restatedFinding what is missed when two people must say yes separately
termsveto barrier, second-opinion parasitism, redundancy collapse
domain_terms[code, review, defect, detect, PR, merge, approval]
2a directions(1) function: banking dual-control — one authoriser cannot force; (2) function: aircraft cockpit — two pilots, one performs, one monitors; (3) scale up: ecosystem — redundancy degrades under pressure (diversity loss, cascade failure); (4) conflict: medical diagnosis — second opinion vs false positive coordination
2b verified(1) Banking dual-control: yes (payment authorisation). (2) Aircraft: verified by standard SOP. (3) Ecosystem: verified by ecology lit on functional redundancy collapse. (4) Medical: verified by Cochrane review on second opinion in low-prevalence screening
2c gapSearch: "divergent assessment mandatory two-person" → military intelligence: BDA (bomb damage assessment) requires two independent analysts; their divergence is logged, not resolved by consensus. origin: search, query: "divergent assessment mandatory two-person"
Landingoperator: 功能(function), action: log divergence (not resolve), subject: the two reviewers, first_step: pick one historical PR with a known missed defect; have each of two reviewers write their findings separately before merging, observable: the two reviewers' finding lists contain items the other didn't spot, why: "want to raise detection rate, but adding people lowers it" ↔ BDA shows logging divergence preserves independent signal that consensus usually masks

C. Terms

Terms marked (中文) are preserved in their original Chinese form (the skill's native language) for the tool's literal check, with English translation in parentheses.


Copyright (c) 2025 benbird316. MIT License.

Related Skills