{
  "markdown": "# Linus Level Skill\n\n[![version](https://img.shields.io/github/v/tag/rsoffer/linus-level-skill?style=for-the-badge&label=Version&color=111827)](https://github.com/rsoffer/linus-level-skill/tags)\n[![license](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](./LICENSE)\n[![skill](https://img.shields.io/badge/Skill-SKILL.md-2563eb?style=for-the-badge)](./skills/linus-level/SKILL.md)\n[![agents](https://img.shields.io/badge/Agents-Codex%20%7C%20Claude%20%7C%20SKILL.md--aware-0f766e?style=for-the-badge)](#copy-paste-install-prompts)\n\n![Linus Level logo](assets/linus-level-logo-lockup-transparent.png)\n\n**Linus Level** gives coding agents like Codex, Claude, and other `SKILL.md`-aware workflows a `1.0-10.0` working-mode dial for software work: from creative vibe-mode prototyping to careful maintainer-grade engineering.\n\nThe name is a software-culture wink to Linus Torvalds' reputation for exacting technical standards and maintainer seriousness. It is not about harsh communication. It is about giving agents a memorable control for how much freedom, skepticism, verification, collaboration, and decision ownership a task deserves. Strictness is only one axis.\n\n## The Problem\n\nAI coding agents are asked to behave in wildly different contexts:\n\n- \"Vibe-code this idea into existence.\" ⚡\n- \"Prototype a weird UI direction quickly.\" ✨\n- \"Patch a production codebase without breaking contracts.\" 🛠️\n- \"Touch auth, data, security, infra, or business rules safely.\" 🔒\n\nWithout calibration, an agent may guess wrong. It may over-engineer a throwaway sketch, or worse, treat a mission-critical production system like a loose prototype.\n\nLinus Level makes the expected behavior explicit.\n\n## ⚡ Quick Start\n\n```text\nUse $linus-level at Linus Level 8.5 for this production codebase task.\n```\n\n```text\nUse Linus Level 2 for fast creative prototyping.\n```\n\n```text\nCalibrate this task with Linus Level before coding.\n```\n\n## 🎛️ The Dial\n\n| Linus Level | Mode | Agent Behavior |\n|---:|---|---|\n| `1.0-1.9` | Vibe mode | Take the lead, infer intent aggressively, and optimize for momentum. |\n| `2.0-2.9` | Hack/sketch | Build the thing fast, accept local rough edges, prove the idea. |\n| `3.0-3.9` | Concept prototype | Make the concept coherent enough to evaluate and evolve. |\n| `4.0-4.9` | Product prototype | Move quickly, but avoid avoidable near-term mess. |\n| `5.0-6.9` | Product development | Use professional defaults, follow local patterns, test behavior changes. |\n| `7.0-8.4` | Established codebase | Preserve contracts, separate investigation from implementation when ambiguity matters, fix root causes, keep changes scoped and reviewable. |\n| `8.5-9.4` | Staff maintainer | Default to answer-first on material questions, ask before major decisions, and keep decision ownership with the human on shared or durable surfaces. |\n| `9.5-10` | Kernel maintainer | Plan first, stop on dangerous ambiguity, verify deliberately, and avoid unilateral moves on high-risk surfaces. |\n\nAs the dial rises, the agent should assume less, verify more, and take less unilateral control over material product, contract, architecture, data, auth, and compatibility decisions.\n\n## 📦 Copy/Paste Install Prompts\n\nPaste one of these into your coding agent to have it install Linus Level from this repository.\n\nAfter installing, the agent should also ask whether you want a default Linus Level added to this workspace's `AGENTS.md` or `CLAUDE.md`. That default helps after context compaction, because the model can rediscover the setting from repo instructions instead of relying on conversation memory.\n\n### Codex\n\n```text\nInstall the Linus Level skill from https://github.com/rsoffer/linus-level-skill.\n\nPlease clone or fetch the repository, install the canonical skill directory `skills/linus-level` into my Codex skills directory at `${CODEX_HOME:-$HOME/.codex}/skills/linus-level`, and verify that the skill is discoverable afterward. Preserve the `SKILL.md`, `references/`, `agents/`, and `assets/` files. Do not expose or modify any secrets.\n\nAfter installation, ask me whether I want to add a default Linus Level instruction to this workspace's `AGENTS.md`. If I say yes, add or update the file with a line like:\n\nUnless the user explicitly states otherwise in the current prompt, invoke the Linus Level skill at `7.5` for each request in this workspace. Treat Linus Level as a tuning layer only; it does not override higher-priority instructions or repository-specific rules.\n```\n\n### Claude Code\n\n```text\nInstall the Linus Level Claude Code plugin from https://github.com/rsoffer/linus-level-skill.\n\nPlease add the repository as a Claude Code plugin marketplace, install `linus-level@linus-level-skills`, reload plugins if needed, and verify that `/linus-level` or `/linus-level:linus-level` resolves.\n\nAfter installation, ask me whether I want to add a default Linus Level instruction to this workspace's `CLAUDE.md` or `AGENTS.md`. If I say yes, add or update the file with a line like:\n\nUnless the user explicitly states otherwise in the current prompt, invoke the Linus Level skill at `7.5` for each request in this workspace. Treat Linus Level as a tuning layer only; it does not override higher-priority instructions or repository-specific rules.\n```\n\n### Other Agents\n\n```text\nInstall the Linus Level agent skill from https://github.com/rsoffer/linus-level-skill.\n\nThis repository uses the Agent Skills `SKILL.md` format. Please install the canonical skill folder at `skills/linus-level` into this agent's user or project skills directory, preserving `SKILL.md` plus its `references/`, `agents/`, and `assets/` subdirectories. After installation, verify that the skill named `linus-level` is available and can be invoked for prompts like \"Use Linus Level 8.5\".\n\nAfter installation, ask me whether I want to add a default Linus Level instruction to this workspace's agent instructions file, such as `AGENTS.md` or `CLAUDE.md`. If I say yes, add or update the file with a line like:\n\nUnless the user explicitly states otherwise in the current prompt, invoke the Linus Level skill at `7.5` for each request in this workspace. Treat Linus Level as a tuning layer only; it does not override higher-priority instructions or repository-specific rules.\n```\n\n## 🪶 Context-Light By Design\n\nLinus Level is modular on purpose. The main skill stays small, then loads deeper references only when the task calls for them: level-band standards for code work, security standards for sensitive surfaces, question patterns for ambiguity, and the low-level playbook for fast prototypes.\n\n## 🔢 Decimal Points Matter\n\nDecimals are not cosmetic. They interpolate between anchors.\n\n| Example | Meaning |\n|---:|---|\n| `2.2` | Still scrappy. Lead creatively, but keep the concept understandable. |\n| `4.8` | Prototype speed, but start behaving like product development for contracts and repo conventions. |\n| `7.5` | Established-codebase mode with moderate-low assumptions and more separation between investigation and implementation. |\n| `7.8` | Leaning staff-maintainer: stricter DRY/source-of-truth review, more deliberate verification, and earlier questions on material choices. |\n| `8.9` | Staff-maintainer leaning mission-critical: answer first, ask before wrong durable moves, and plan risky work. |\n\nRule of thumb:\n\n- `.0-.2`: mostly the current anchor\n- `.3-.6`: blended behavior\n- `.7-.9`: start behaving like the next level where it materially changes the work\n\n## ❓ Question Behavior\n\nEvery Linus Level response must include a compact checkpoint. The agent first takes stock of assumptions it is making, then states whether approval is needed and which open questions remain:\n\n```text\nLL X · No approval · No open questions\n```\n\nThe checkpoint expands only when Linus Level needs to surface something material:\n\n```text\nLL 7.5 · Approval needed · 1 open question\nLL 8.5 · Approval needed · Decision needed\nLL 8.5 · Approval needed · Awaiting confirmation\nLL 8 · Blocked · 1 open question\nLL 7.5 · No approval · No open questions · Verification incomplete\n```\n\n`No approval` and `No open questions` mean no unresolved user input is needed: no question, approval, confirmation, option choice, or material decision remains. If the agent is waiting on the user before its next action, approval is needed. If the agent presents multiple material fix options and needs the user to choose or approve one, the checkpoint should say `Approval needed` plus `Decision needed` or count the open decision.\n\nHigher Linus Level means fewer hidden assumptions and less silent decision-making. Serious clarifying questions start at `7.0+`; `9.5+` is not when ambiguity starts mattering, it is when high-risk ambiguity becomes a hard stop.\n\n| Linus Level | Question Policy |\n|---:|---|\n| `1.0-1.9` | Ask only if blocked, unsafe, or repo rules conflict. Otherwise take the wheel. |\n| `2.0-2.9` | Ask only for hard blockers or major product-direction forks. |\n| `3.0-3.9` | Ask if ambiguity changes the concept, audience, or core interaction. |\n| `4.0-4.9` | Ask if ambiguity could make the prototype hard to evolve. |\n| `5.0-6.9` | Ask when ambiguity affects user-visible behavior, data shape, architecture, or verification. |\n| `7.0-7.9` | Ask serious questions before changing contracts, business rules, shared state, persistence, auth, payments, analytics, workflows, or long-term structure. Treat questions and design prompts as investigation-first when ambiguity matters. |\n| `8.0-8.4` | Ask earlier and more precisely; if two plausible fixes have different long-term tradeoffs, surface them before choosing rather than silently picking one. |\n| `8.5-9.4` | Default to answer-first on material questions. Stop before material assumptions, migrations, dependencies, fallbacks, feature flags, compatibility paths, or accepted debt. |\n| `9.5-10` | Plan first; do not proceed through ambiguity that affects correctness, security, data, contracts, operations, or business meaning. |\n\nAt high Linus, prompts like \"why\", \"does\", \"should\", \"is there\", \"what about\", and \"how would\" should be treated as questions, not as permission to edit code. If implementation seems useful, the agent should propose it and ask.\n\nGood high-Linus question:\n\n```text\nBefore I change this: should this ranking rule apply only to Session Finder, or is it a shared forecast-quality rule used elsewhere? That determines whether this is a local filter change or a shared scoring-rule change.\n```\n\nGood low-Linus behavior:\n\n```text\nI'll pick a bold direction and build the first usable version. I'll keep the code easy enough to continue from, but I won't stop for minor choices.\n```\n\n## 🛠️ Engineering Standards By Level\n\nThe skill teaches coding agents which standards become expected or non-negotiable as the dial rises.\n\n| Standard | Becomes Non-Negotiable |\n|---|---:|\n| Follow system, user, repo, and tool instructions | Always |\n| Ask before bypassing repo rules | Always |\n| No secrets, malicious behavior, or hidden partial completion | Always |\n| Include a compact checkpoint in every response: inventory assumptions first, then state approval and open-input status, expanding for material surfaced states and never saying `No approval` or `No open questions` when approval, confirmation, option choice, or a material decision remains | Always |\n| Keep changes scoped | `5.0+` |\n| Match existing style before inventing patterns | `5.0+` |\n| Do not silently hide failures | `5.0+` |\n| Prefer cohesive, reviewable modules over large catch-all files | `5.0+` |\n| Preserve public API/UI contracts unless explicitly migrating | `6.0+` |\n| Tests for behavior changes | `6.5+` expected, stricter near `7.0+` |\n| Separate investigation from implementation when ambiguity is material | `7.0+` |\n| Ask serious clarifying questions when ambiguity affects product behavior, contracts, business rules, shared state, persistence, auth, payments, analytics, workflows, or architecture | `7.0+` |\n| Root-cause fixes over symptom patches | `7.0+` |\n| No unrelated refactors in targeted fixes | `7.0+` |\n| DRY for business rules, contracts, validation, scoring, permissions, cache keys, and UI state authority | `7.0+`, strict at `8.5+` |\n| Named constants for thresholds, weights, limits, and domain magic numbers | `7.0+` |\n| Ask before introducing new libraries, frameworks, paradigms, state models, or cross-cutting abstractions in an existing codebase | `7.5+` |\n| Flag large files as possible candidates for proper refactors when they create review, testing, ownership, or comprehension risk | `7.5+` |\n| Surface tradeoffs before choosing between materially different fixes | `8.0+` |\n| Treat questions and architecture prompts as answer-first rather than edit permission | `8.0+`, stronger at `8.5+` |\n| Stop before material assumptions, new complexity, compatibility paths, feature flags, fallbacks, migrations, dependencies, or accepted debt | `8.5+` |\n| Keep decision ownership with the human for material contract, architecture, compatibility, persistence, auth, data, or business-behavior choices unless implementation is explicit | `8.5+` |\n| Scale edit scope with Linus Level: lower levels allow broader exploration; higher levels increasingly favor surgical, reviewable edits | Always; stricter as level rises |\n| Treat existing architecture, framework choices, and module boundaries as authoritative unless explicitly revisiting them | `8.5+` |\n| No hidden fallbacks, shims, shadow state, or parallel implementations without approval | `8.5+` |\n| No timing hacks to mask lifecycle or sequencing bugs | `8.5+` |\n| Docs travel with behavior/config/workflow/architecture changes | `8.5+` |\n| Plan before implementation | `9.5+` |\n| Hard stop on unresolved ambiguity affecting correctness, security, data, operations, contracts, or business meaning | `9.5+` |\n\n## 🔒 Security Posture By Level\n\nSecurity is not bolted on. Linus Level tunes security discipline too.\n\n| Security Standard | Becomes Non-Negotiable |\n|---|---:|\n| Never commit or expose secrets, tokens, keys, credentials, or `.env` values | Always |\n| Never log secrets, passwords, tokens, authorization headers, session ids, or sensitive personal data | Always |\n| Treat external input as untrusted | `5.0+` |\n| Use parameterized queries or safe query builders | `5.0+` |\n| Avoid `eval`, unsafe deserialization, shell interpolation, and raw path/URL construction from user input | `5.0+` |\n| Authorization must be explicit and fail closed | `7.0+` |\n| Use least privilege for service roles, storage, DB access, CI credentials, and OAuth scopes | `7.0+` |\n| Add negative tests for security-sensitive behavior | `7.0+` |\n| Ask before touching auth, sessions, secrets, PII, encryption, file upload, webhooks, admin surfaces, production config, or RLS/security policies | `8.5+` |\n| No custom crypto unless explicitly approved and justified | `8.5+` |\n| No fallback from a secure path to a less secure path | `8.5+` |\n| Threat-model note before security-sensitive implementation | `9.5+` |\n| Exposed secrets, auth bypass, privilege escalation, data leak, high/critical dependency vulnerability, or production security misconfig are blockers | `9.5+` |\n\n## 🧱 Repository Rules Still Win\n\nLinus Level is a tuning layer, not an authority layer.\n\nIf a repository says \"always use DRY\" and you ask for `Linus Level 1`, the agent should not silently ignore the repo. It should say:\n\n```text\nYou asked for Linus 1, but this repo requires DRY business logic and contract stability. I can move quickly within those rules, or you can explicitly approve a temporary exception for this local prototype area.\n```\n\nPrecedence:\n\n1. system, developer, tool, and safety instructions\n2. current-turn user instructions\n3. repository instructions such as `AGENTS.md`, `CLAUDE.md`, `.claude/rules/`, README files, docs, and local conventions\n4. Linus Level behavior\n5. agent defaults\n\n## 💬 Example Prompts\n\n```text\nUse Linus Level 1.5. Build a playful one-screen web toy that lets me remix a product name into ridiculous startup taglines.\n```\n\nThe agent should take creative lead, make taste calls, avoid over-planning, and optimize for a fun first result.\n\n```text\nUse Linus Level 4.8. Add a rough but usable onboarding checklist to this app so we can test whether new users understand the core workflow.\n```\n\nThe agent should move quickly, follow obvious local patterns, and avoid choices that would make the prototype painful to evolve.\n\n```text\nUse Linus Level 7.8. Fix the account settings bug where changing the display name sometimes reverts after refresh.\n```\n\nThe agent should inspect surrounding state/data flow, preserve API and UI contracts, fix the root cause, and run focused verification.\n\n```text\nUse Linus Level 8.8. Add a new \"quality score\" filter to the session-ranking feature in this established production app.\n```\n\nThe agent should ask before changing scoring semantics, centralize business rules, avoid duplicated thresholds, update tests, and document behavior changes. If the user had instead asked whether the filter should exist or where it should live, the agent should answer first before editing.\n\n```text\nUse Linus Level 9.7. Update the password reset flow to add device-session revocation after a successful reset.\n```\n\nThe agent should plan first, identify trust boundaries, ask about auth/session semantics before implementation, add negative tests, and stop on security ambiguity.\n\n```text\nUse Linus Level 9.5. Prepare a database migration that changes how billing entitlements are represented, but do not run it.\n```\n\nThe agent should treat data shape and billing authority as high-risk, ask clarifying questions, keep the migration reviewable, and avoid authoritative actions.\n\n## 🧭 Default Workspace Setting\n\nLinus Level works best when a project carries its normal default in repo instructions. The main reason is context compaction: long agent sessions eventually get summarized, and that summary can lose the exact Linus Level the model was supposed to keep using. A short line in `AGENTS.md`, `CLAUDE.md`, or the equivalent repo instructions file gives the agent a durable source of truth it can reload after compaction, restarts, or handoffs.\n\nAdd this to `AGENTS.md`, `CLAUDE.md`, or the equivalent agent instructions file for the workspace:\n\n```md\nUnless the user explicitly states otherwise in the current prompt, invoke the Linus Level skill at `7.5` for each request in this workspace. Treat Linus Level as a tuning layer only; it does not override higher-priority instructions or repository-specific rules.\n```\n\nAdjust `7.5` to match the repo. A greenfield prototype might default closer to `4.0`; an established production app usually belongs around `7.5-8.5`.\n\n## 🧩 Marketplace Notes\n\nLinus Level is distributed as a portable `SKILL.md` repository today. It also includes Codex and Claude plugin metadata so it can be installed through compatible marketplace flows.\n\n| Harness | Current path | Notes |\n|---|---|---|\n| Codex | GitHub repo / local skill install | Uses `.codex-plugin/plugin.json` plus `skills/linus-level/`. |\n| Claude Code | Repository marketplace | Uses `.claude-plugin/marketplace.json` and `.claude-plugin/plugin.json`. |\n| OpenAI hosted skills | Zip upload | Package `skills/linus-level/` with `scripts/package-skill.sh`. |\n| Claude custom skills | Zip or project/user skill folder | Same canonical `skills/linus-level/` directory. |\n| Gemini CLI | Extension install | Uses root `gemini-extension.json` plus `skills/linus-level/`. |\n| Factory Droid | Repository marketplace | Uses `.factory-plugin/marketplace.json` and `.factory-plugin/plugin.json`. |\n| GitHub Copilot CLI | Repository marketplace | Uses `.github/plugin/marketplace.json`; Copilot can also read the Claude plugin manifest. |\n| OpenCode | Native skill discovery | Uses the canonical `skills/linus-level/SKILL.md` layout. |\n| Other `SKILL.md` agents | Filesystem install | Preserve `SKILL.md`, `references/`, `agents/`, and `assets/`. |\n\nSee [DEPLOYMENT.md](./DEPLOYMENT.md) for publishing steps and marketplace research.\n\n## Skill Structure\n\n```text\nassets/\n  linus-level-logo-lockup-transparent.png\n  linus-level-app-icon.png\nskills/linus-level/SKILL.md\nskills/linus-level/agents/openai.yaml\nskills/linus-level/references/\n.codex-plugin/plugin.json\n```\n\nThe `.codex-plugin/` directory is a Codex compatibility wrapper. The canonical skill is `skills/linus-level/`.\n\n## Claude Code Install\n\nLinus Level can be installed in Claude Code as a plugin from this repository's marketplace:\n\n```text\n/plugin marketplace add rsoffer/linus-level-skill\n/plugin install linus-level@linus-level-skills\n/reload-plugins\n```\n\nThe plugin exposes the skill as:\n\n```text\n/linus-level:linus-level\n```\n\nFor local development, load the repo directly:\n\n```bash\nclaude plugin validate .\nclaude plugin marketplace add \"$(pwd)\" --scope local\nclaude plugin install linus-level@linus-level-skills --scope local\n```\n\nClaude Code also discovers standalone project skills from `.claude/skills/` and user skills from `~/.claude/skills/`. To install Linus Level as a standalone user skill instead of a plugin, copy or symlink the canonical skill directory:\n\n```bash\nmkdir -p ~/.claude/skills\nln -s \"$(pwd)/skills/linus-level\" ~/.claude/skills/linus-level\n```\n\nFor a project-local install, place or symlink it at:\n\n```text\n<project>/.claude/skills/linus-level\n```\n\nIf a project already has `AGENTS.md`, add a `CLAUDE.md` that imports it so Claude Code sees the same repo rules:\n\n```md\n@AGENTS.md\n```\n\n## Codex Install\n\nFor skill-only use in Codex, copy or symlink `skills/linus-level` into:\n\n```text\n${CODEX_HOME:-$HOME/.codex}/skills/linus-level\n```\n\nFor local Codex plugin presentation, clone or copy this repository into a plugin directory:\n\n```bash\nmkdir -p ~/plugins\ngit clone git@github.com:rsoffer/linus-level-skill.git ~/plugins/linus-level\n```\n\nThen add this entry to `~/.agents/plugins/marketplace.json`:\n\n```json\n{\n  \"name\": \"linus-level\",\n  \"source\": {\n    \"source\": \"local\",\n    \"path\": \"./plugins/linus-level\"\n  },\n  \"policy\": {\n    \"installation\": \"AVAILABLE\",\n    \"authentication\": \"ON_INSTALL\"\n  },\n  \"category\": \"Productivity\"\n}\n```\n\nFor a home-local marketplace, `./plugins/linus-level` resolves to:\n\n```text\n~/plugins/linus-level\n```\n\nSee `marketplace.example.json` for a complete sample marketplace file.\n\n## Gemini CLI Install\n\nLinus Level can be installed as a Gemini CLI extension from this repository:\n\n```bash\ngemini extensions install https://github.com/rsoffer/linus-level-skill\n```\n\nThe extension exposes the bundled skill from `skills/linus-level/SKILL.md`.\n\n## Factory Droid Install\n\nLinus Level can be installed as a Droid plugin from this repository's Factory marketplace:\n\n```bash\ndroid plugin marketplace add https://github.com/rsoffer/linus-level-skill\ndroid plugin install linus-level@linus-level-skills\n```\n\nFor local development:\n\n```bash\ndroid plugin marketplace add \"$(pwd)\"\ndroid plugin install linus-level@linus-level-skills\n```\n\n## GitHub Copilot CLI Install\n\nLinus Level can be installed as a GitHub Copilot CLI plugin from this repository's marketplace:\n\n```bash\ncopilot plugin marketplace add https://github.com/rsoffer/linus-level-skill\ncopilot plugin install linus-level@linus-level-skills\n```\n\nCopilot CLI also supports direct GitHub installs:\n\n```bash\ncopilot plugin install rsoffer/linus-level-skill\n```\n\n## OpenCode Install\n\nOpenCode discovers Agent Skills from project and user skill directories. Install Linus Level by copying or symlinking the canonical skill directory into one of OpenCode's native locations:\n\n```bash\nmkdir -p ~/.config/opencode/skill\nln -s \"$(pwd)/skills/linus-level\" ~/.config/opencode/skill/linus-level\n```\n\nFor a project-local install, place or symlink it at:\n\n```text\n<project>/.opencode/skill/linus-level\n```\n\n## Deployment\n\nFor hosted OpenAI and Claude skill upload, GitHub release steps, and bundle packaging details, see [DEPLOYMENT.md](DEPLOYMENT.md).\n\n## License\n\nMIT. Copyright (c) 2026 Ron Soffer.\n",
  "bytes": 24003,
  "sha": "1560eb65007aeaeb30b491abe89fc25d9da1f23f450e4e869b82de39209207ba",
  "repo_slug": "rsoffer/linus-level-skill",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_rsoffer_linus_level_skill_linus_level_f7530afb/readme"
}