Nobrainer Tech Skills

Give the agent one outcome. nobrainer-ultra inspects the real project, asks at most one focused requirements round, builds a complete skill-routed execution map, creates a minimal specialist team when it will genuinely help, and drives the approved work until verified delivery or a real owner gate.

Continuous improvement beats delayed perfection. A small task stays small. A non-trivial task gets enough structure to be reliable, but no speculative framework, automatic swarm or documentation theatre.

Start with one skill

Use nobrainer-ultra (nb-ultra) for setup or any non-trivial outcome:

DRIFT_CHECK -> BUDDY -> EXECUTION_MAP -> READY_GATE -> AUTOPILOT
            -> VERIFY -> RECEIVE_AUDIT -> LEARN

• BUDDY is the first and only ordinary clarification stage.
• EXECUTION_MAP is the complete TODO: every stage has one owning skill or capability, dependencies, write scope, evidence, session and owner gate.
• GOAL_LOOP makes progress visible: the map row and one compact goal snapshot are updated together before/after each auditable transition; it is not a second mutable state store.
• AUTOPILOT continues through routine approved work without repeated check-ins.
• nobrainer-team selects the minimum useful capabilities; nobrainer-dispatcher schedules only approved ready work in bounded batches; nobrainer-sessions creates or reuses exact visible sessions only when parallelism, isolation, handoff or independent evidence earns the cost.
• Failed review returns to nobrainer-build; changed code invalidates old proof.
• Merge, deploy, publishing, spending, credentials, destructive operations and production mutation remain owner gates unless exact authority is already recorded.

The two execution axes stay independent:

CONTROL_MODE: BUDDY -> AUTOPILOT
SESSION_MODE: MAIN | MULTI_SESSION

Autopilot can run in one MAIN session. A multi-session plan is not automatically autonomous. This keeps the workflow understandable and avoids agent theatre.

Fifteen skills, distinct ownership

Aliases are trigger phrases, not duplicate directories. Each skill owns one recurring boundary:

The curation audit records why each skill exists and what belongs in another skill instead of becoming a sixteenth trigger.

Correct once, improve permanently

Ultra contains portable semantic hooks for four events:

• OWNER_DECISION_CHANGED updates the canonical decision, marks the old value superseded and invalidates dependent TODO items and evidence;
• AGENT_ERROR_CORRECTED fixes the active result and classifies one minimal prevention candidate: AUTO_SCOPED may persist it to one governed canonical project-local store, ASK prepares one exact diff, and OFF keeps it task-local without a durable diff;
• REVIEW_FAILED creates a bounded Build correction and sends fresh evidence back to Review;
• REPEATED_DEFECT stops blind retries and invokes RCA with the prior failure fingerprint.

Only durable, sourced, authorized and non-secret knowledge is promoted through nobrainer-wiki. One mutable fact has one canonical owner; the system does not append contradictory copies to the plan, instructions and wiki. Project setup records LEARNING_WRITE_POLICY: AUTO_SCOPED | ASK | OFF, so an owner can enable automatic project-local learning without granting global or publishing authority.

Quality without AI slop

The shared delivery contract operationalizes:

• KISS: the simplest complete design wins;
• YAGNI: no speculative extension points or future options;
• DRY: deduplicate owned knowledge and state, not incidental similarity;
• SOLID: cohesive responsibilities and stable boundaries without class or interface ceremony;
• evidence: no invented APIs, fake runtime claims, placeholder logic, swallowed errors, generic prose, broad unrelated rewrites or mock-only confidence;
• content quality: purpose, audience, correctness sources, completeness, coherence and target-workflow usefulness are frozen before execution.

If a decision-relevant fact may be current, niche, uncertain, high-stakes or source-attributed, Ultra routes the smallest sufficient check through Research. If primary evidence is unavailable, it says RESEARCH_BLOCKED instead of guessing.

Compatibility is a proof ladder

All clients consume the same skills/ tree. Thin adapters cover Claude Code, Codex, Cursor, OpenCode, Gemini CLI, Kimi Code and Pi; the portable Agent Plugin manifest and project instructions are the fallback for other Agent Skills consumers.

Compatibility claims use five distinct levels:

SOURCE_VALIDATED -> REPOSITORY_CHECKED -> CLIENT_LOADED
                 -> RUNTIME_VERIFIED -> DISTRIBUTED

A valid manifest does not prove clean-session routing. A local test does not prove production. See Compatibility for current proof and Testing for acceptance evidence.

Install safely

Clone a reviewed ref, validate it, preview exact targets, then apply:

(
  set -u
  : "${NB_REVIEWED_COMMIT:?set a reviewed full 40-character commit SHA}"
  test "${#NB_REVIEWED_COMMIT}" -eq 40 || exit 2
  case "$NB_REVIEWED_COMMIT" in *[!0-9a-f]*) exit 2 ;; esac
  git clone --no-checkout https://github.com/nobrainer-tech/nobrainer-tech-skills.git || exit 3
  cd nobrainer-tech-skills || exit 3
  git checkout --detach "$NB_REVIEWED_COMMIT" || exit 3
  test "$(git rev-parse HEAD)" = "$NB_REVIEWED_COMMIT" || exit 3
  python3 scripts/validate_skills.py --suite || exit 4
  python3 scripts/install_skills.py --client codex || exit 4
  python3 scripts/install_skills.py --client codex --apply || exit 4
)

Set NB_REVIEWED_COMMIT to the exact full commit SHA you reviewed. Tags and branches are rejected because they can move; every failed gate stops before the next command.

The installer defaults to all fifteen canonical skills, supports an exact subset, refuses foreign targets and can use links or copies. Restart the client and perform clean-session discovery before claiming runtime installation. Full client-specific steps and rollback are in Installation.

Version v1.2.1 is the latest fully accepted GitHub source release. It passed exact tag-to-commit readback, merged-main CI, archive parity, 88/88 tests without .git, a fresh secret scan and an isolated fifteen-skill copy installation. To reproduce the reviewed source:

git checkout --detach 1949dd99c962662f7c275d3e57288bd0a8cd184a
test "$(git rev-parse HEAD)" = "1949dd99c962662f7c275d3e57288bd0a8cd184a"
python3 scripts/validate_skills.py --suite
python3 -m unittest discover -s tests -q

v1.2.0 remains published but failed archive acceptance; its exact boundary is recorded separately. GitHub reports the v1.2.1 release object as non-immutable and tag protection was not independently verified, so security-sensitive consumers should pin the full commit SHA. v1.1.0 remains the accepted rollback anchor at full commit d6931a1006bf0180955d8437fd93174b6a512428.

One source, thin adapters

skills/               canonical portable behavior
adapters/bootstrap.md small session-start route to Ultra
hooks/                tested client lifecycle adapters
scripts/              validation and conflict-safe installation
tests/                deterministic and behavior-contract gates
docs/                 compatibility, curation, eval and release evidence
assets/               brand and workflow diagrams

Client-specific forks of a skill are prohibited. External skills discovered by Team are untrusted input: inspect the exact source/ref, instructions, scripts, permissions, network/credential behavior, trigger overlap and rollback. Prefer temporary project-scoped use; persistent or global installation is an owner gate.

Attribution

• nobrainer-autoimprove is an independent adaptation of Andrej Karpathy's autoresearch measure-change-keep loop.
• nobrainer-wiki is an independent adaptation of Andrej Karpathy's LLM wiki concept.
• Other external design sources remain cited inside the exact skill where they influenced a behavior contract.

Contributing and security

Read CONTRIBUTING.md, SECURITY.md and RELEASE-NOTES.md. Every change goes through a focused PR, pressure scenario, validators, diff review and secret scan. Do not report publication, distribution, live routing or user-visible success without readback from that layer.

NoBrainer Tech builds practical agentic workflows for teams that want speed without surrendering control. Learn more at nobrainer.tech or browse ready-to-use workflow products on Gumroad.