LeostrukaLeostruka/devin-bundle/skills/ask-bundle/SKILL.md

ask-bundle

Skill0 starsChanged 3 months agoMITView on GitHub

Use when deciding which skill or flow fits your situation — the meta-router entry point for this bundle (direct specialist skills, multi-skill flows, local AFK issues), or when the request is vague and needs the quick-start menu. Routes then defers to the chosen specialist — does not execute the work itself.

In this repository110 other files it gives its agents.
- AGENTS.mdAGENTS.md
- skills/project-bootstrap/templates/agents.mdAGENTS.md
- a11y-auditSkill
- agentic-ragSkill
- agent-reachSkill
- ai3d-genSkill
- ai-coding-dictionarySkill
- ai-toolsSkill
- animation-directionSkill
- api-specSkill
- architecture-diagramsSkill
- architectureSkill
- ascii-artSkill
- binary-triageSkill
- bragSkill
- brag-slimSkill
- career-opsSkill
- code-reviewSkill
- computer-useSkill
- context7Skill
- context-hygieneSkill
- creative-engineeringSkill
- cu-realtimeSkill
- data-analystSkill
- databaseSkill
- dead-wireSkill
- debuggingSkill
- deploySkill
- devin-configSkill
- dispatching-parallel-agentsSkill
- dmaSkill
- dockerSkill
- drift-reportSkill
- e2e-testingSkill
- edge-casesSkill
- executionSkill
- fact-checkSkill
- finishing-a-development-branchSkill
- firmware-probeSkill
- frontend-designSkill
- gatesSkill
- ghidraSkill
- ghSkill
- github-actionsSkill
- git-workflowsSkill
- grillingSkill
- handoffSkill
- humanizerSkill
- hyperframesSkill
- i18nSkill
- image-forensicsSkill
- impeccableSkill
- implement-layaSkill
- intakeSkill
- jiraSkill
- knowledge-modelingSkill
- laya-orchestratorSkill
- learn-modeSkill
- mcp-governanceSkill
- media-toolsSkill
- The first 60 shown.

The file

We split this skill into the rules it gives an agent

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

≈0
Common · estimate
Many files like this have a rule of this kind.
≈1
Distinctive · estimate
This author's own choices. Worth a look.
4
Very specific
Tied to their project's names, files or tools. Probably skip.

Common
Distinctive
Very specific

Very specific:
Run project verification (e.g.
line 23
Very specific:
Context hygiene: keep 1–3 in one window until tickets are cut.
line 75
Very specific:
No spec → grilling/planning spec → .devin/scratch/<slug>/spec.md.
line 105
Very specific:
Verify files + DAG (glob, read, parse Status:/Blocked by:).
line 108
Distinctive:
Verify with tools before asserting.
line 114

≈ “Common” is an estimate: at least 1 in 5 of the 350,495 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

Ask Bundle — the bundle router

One entry point: classify the objective, route to matching skills, keep control through verified completion. You don't remember every skill, so ask.

Detail docs: modes/orchestration-detail.md (full orchestration procedure, forbidden actions, priority hierarchy), modes/flows-detail.md (verbose flow map), PHASE-BOUNDARIES.md (context-handoff decision tree).

TL;DR

Self-check: scope exactly, telegraphic, skills first, verify, no opinion.
Classify objective; route directly to matching skill(s).
Unclear objective ("ask-bundle"/"start") → quick-start menu via ask_user_question.
3+ steps → todo_write; each step gets a VF (gate:/expect:/evidence:).
qa-ci re-runs every non-trivial gate on a clean checkout.
Run project verification (e.g. python audit.py, pytest) before done.

Situation router

Situation	Entry	Next
Build/change something	`grilling` (intent) or `execution` cadence if trivial	→ `planning` spec→tickets → `execution`+`testing` → `security` (API/DB/secrets/infra) → `code-review` → `gates` → `finishing-a-development-branch`
Run AFK/unattended	`execution` execution (needs ready-for-agent issues)	see AFK creation below
Hard/intermittent bug	`debugging`	→ `testing` regression → `architecture` if no seam
CI failing	`debugging` ci mode
Triage incoming issues	`intake`	→ `execution`
Large foggy multi-session effort	`planning` wayfinder	→ spec → tickets → implement
Prototype to settle a question	`prototype` (via `handoff`)	back to `grilling`/`planning`
Research/deep exploration	`research`	feeds `grilling`/spec
Fact-check article/draft	`fact-check`	→ `humanizer` on accepted fixes
De-AI-ify prose	`humanizer`
Need input from another person	`planning` questionnaire
Git merge/rebase conflict	`git-workflows`
Improve architecture/deep modules	`architecture`	→ `grilling` if it generates an idea
Evolve skill/rule/hook/MCP	`self-improvement`	→ `writing-skills` (one skill), `devin-config` (new capability)
Release/deploy/rollback	`deploy`	→ `gh`, smoke tests
Security assessment	`security`	→ `execution` for remediations
Data query/analysis/charts	`data-analyst`
UI/UX polish	`impeccable`	→ `a11y-audit`/`e2e-testing`
Observability infra	`observability-quality`
API or DB design	`api-spec` or `database`	→ `execution`
Performance/cost	`performance` or `context-hygiene`
Human-only procedure	`wizard`
Guided learning	`teach`
User owns design, agent teaches + writes	`learn-mode`	off-ramp to `execution` once design approved
Write PR body/description	`pr`	→ `gh` to create/update
Session retrospective / improve agent env	`retro`	findings → `continuous-improvement` or issues
Husky/lint-staged pre-commit setup	`setup-pre-commit`
Set up repo for Devin	`project-bootstrap`
Not sure / no match	`skill-discovery`	evaluate/install

The main flow: idea → ship

grilling (with-docs) — sharpen the idea by interview; stateful in .devin/CONTEXT.md + adr/. Stateless mode when no working directory.
Runnable question? → detour: handoff out → prototype → handoff back.
Multi-session build?
- Yes → planning spec → tickets (tracer bullets + blocking edges; .devin/scratch/<feature>/issues/ on local tracker) → execution per ticket, clearing context between. Single focused session alternative: planning plan-doc → execution.
- No → execution implement right here.
Either way: testing TDD inside → code-review (Standards+Spec) → security when touching API/DB/secrets/endpoints/infra → gates → finishing-a-development-branch.

Context hygiene: keep 1–3 in one window until tickets are cut; each implementation starts fresh. Approaching the smart zone (~150k) → compact at the nearest phase boundary (PHASE-BOUNDARIES.md).

On-ramps

Bugs/requests piling up → intake triage (issues you didn't create).
Something's broken → debugging (tight feedback loop first).
Huge foggy effort → planning wayfinder (decision-ticket map; hands off to spec when clear — never loop straight into implement).
Codebase health → architecture (deepening opportunities generate ideas).

Vocabulary underneath

knowledge-modeling — domain language (.devin/CONTEXT.md, ADRs) + ontology validation.
architecture — deep-module vocabulary (module/interface/depth/seam).
ai-coding-dictionary — canonical AI-coding jargon.

Quick-start menu (vague request)

ask_user_question with 2–4 options:

Build/change something → grilling or execution cadence
Improve a skill/rule/hook/MCP → self-improvement
Debug/research → debugging / research
Set up repo / run AFK → project-bootstrap / execution afk

Quick AFK issue creation

Confirm feature slug + objective.
No spec → grilling/planning spec → .devin/scratch/<slug>/spec.md.
planning tickets → one file per ticket issues/<NN>-<slug>.md, Status: ready-for-agent, Blocked by:, acceptance checkboxes.
Verify files + DAG (glob, read, parse Status:/Blocked by:).
execution execution only on explicit user authorization.

Hard constraints (never violated)

Safety + pinned AGENTS.md rules (2, 5, 7, 12-19, 21).
Verify with tools before asserting.
Execute exactly what was asked, without opinion.

Then: usefulness → ease → quality of experience → technical coherence → performance.

Forbidden: deduce without tools; start non-trivial work without skill discovery; mark completed without independent qa-ci PASS; override qa-ci FAIL; push/commit with failing checks; AI signatures; display secrets; destructive actions without confirmation; subagent_explore/paid models on a free parent; execution without ready-for-agent issues; read/edit tests/held-out/ from implementer context; reuse implementer shell for qa-ci without reinstalling pinned deps.

Bundle context

Validated CLI: {{VALIDATED_CLI_VERSION}} (data/bundle-identity.json).
Models: data/bundle-models.json — parent BUNDLE_DEFAULT_MODEL; subagents BUNDLE_MAX_MODEL/BUNDLE_MEDIUM_MODEL, all free. No paid aliases on a free parent.
Issue tracker: .devin/scratch/<feature>/ + .devin/agents/issue-tracker.md, triage-labels.md.
Verification baseline: python audit.py, python -m pytest.
Laya is NOT wired into agent routing — zero-shot accuracy was too low to justify it (see plan 2026-09-22-laya-frentes-de-acao.md). extensions/laya-tools + implement-laya remain for per-project use.

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.

Check your setup, free