Agent skill

Theorist

by blader in blader/theorist

Maintain a per-repo THEORY.MD as a continuously updated narrative of the operating theory behind the current work.

MITAuto-check passedProductivity & Automation

Install Theorist

skills CLI
$ npx skills add blader/theorist --skill theorist -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install blader/theorist theorist --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
theorist
GitHub stars
191
Token cost
~1.7k tokens
SKILL.md length
776 words
Files
3
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

Maintain a per-repo THEORY.MD as a continuously updated narrative of the operating theory behind the current work.

  • Tasks that involve Task management
  • SKILL.md covers What THEORY.MD Is, What THEORY.MD Is Not, Session Behavior and Document Structure, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Theorist is an agent skill from blader/theorist. Maintain a per-repo THEORY.MD as a continuously updated narrative of the operating theory behind the current work. Activates EVERY session and stays active throughout the session. Requires frequent in-session rewrites as new learnings land (major result, verification outcome, or strategy pivot). Not a log, not a plan, not a todo list — a cohesive document describing the higher-level thinking, systematic strategy, and motivation behind the work as it evolves. Updated end-to-end (rewritten, not appended) as…

Its SKILL.md is about 1.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `README.md`).

It sits in Productivity & Automation, covering Task management. The repository describes itself as: A Codex/Claude skill that maintains per-repo operating theory documents. The licence is MIT.

When your agent uses it

  • Tasks that involve Task management

Example prompts

  • “/theorist”

What it can do on your machine

Read from SKILL.md and the folder at commit 732d8d0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Theorist loads about 1.7k tokens when it runs. Until then it costs about 136 tokens; SKILL.md has 776 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~136
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from blader/theorist at commit 732d8d0, republished under its MIT licence (© blader). 776 words, ~1,666 tokens.

Download SKILL.mdSave it as .claude/skills/theorist/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
theorist
description
Maintain a per-repo THEORY.MD as a continuously updated narrative of the operating theory behind the current work. Activates EVERY session and stays active throughout the session. Requires frequent in-session rewrites as new learnings land (major result, verification outcome, or strategy pivot). Not a log, not a plan, not a todo list — a cohesive document describing the higher-level thinking, systematic strategy, and motivation behind the work as it evolves. Updated end-to-end (rewritten, not appended) as understanding deepens.
author
blader
version
1.3.0
date
2026-02-28

Theorist

You maintain a per-repo narrative document at THEORY.MD that captures the operating theory of the work being done. This is not a plan, not a log, not a task list. It is a living essay that describes why the work exists, what the systematic strategy is, and how the current approach connects to the larger picture.

This skill is always active during every session. No trigger required. Once active in a session, it stays active for the full session.

What THEORY.MD Is

A cohesive narrative document — typically 1-3 pages — that a thoughtful collaborator could read to understand:

  • The problem thesis: What problem is being solved and why it matters. Not "fix bug X" but "the export pipeline assumes Y, which breaks under Z."
  • The operating theory: The current mental model of how the system works and where the leverage points are. What has been tried, what was learned, and what that implies about the shape of the solution.
  • The systematic strategy: Not task-by-task steps, but the higher-order approach. Why this sequence of work? What principle connects the changes?
  • Key discoveries and pivots: Moments where understanding shifted. What was the old theory, what broke it, and what replaced it.
  • Open questions and uncertainties: What is still unknown. Where the current theory might be wrong. What would change the approach.

What THEORY.MD Is Not

  • Not a changelog or log: Never append timestamped entries. The document is rewritten holistically as understanding evolves.
  • Not a plan or todo list: No task items, checkboxes, or step-by-step instructions. A plan says "do X then Y." A theory says "X matters because of Y, and the right lever is Z."
  • Not a postmortem: Written in the present tense of ongoing work, not retrospectively about completed work.
  • Not a status report: No "today I did X." Instead: "The current approach is X because the evidence shows Y."

Session Behavior

Starting a Session

At session start, if THEORY.MD exists, read it. Use it to orient yourself to the work. Do not announce that you read it.

If meaningful work begins and no THEORY.MD exists yet, create one once you have enough context to write a meaningful narrative (not before — don't create an empty skeleton).

During Work

Update THEORY.MD when understanding shifts meaningfully:

  • A root cause is identified that changes the approach.
  • A strategy pivot happens (tried X, learned Y, now doing Z).
  • A key discovery narrows or expands the problem scope.
  • The systematic approach crystallizes or changes direction.
  • An open question gets answered, or a new uncertainty emerges.

Do NOT update on every small code change. Update when the theory changes, not when the code changes.

Show full SKILL.md (338 more words)Show less
Update Cadence (Strict)

Theorist should refresh frequently during active work, not just at major milestones or session end.

  • Trigger an update after each major work loop:
    • investigate,
    • implement,
    • verify (tests/benchmarks/repro checks).
  • Trigger an update whenever verification materially changes confidence (new failure mode, passing fix confirmation, large benchmark shift).
  • Trigger an update when 2-3 meaningful learnings have accumulated, even if they happened close together.
  • If active work continues for ~10 minutes without a theory refresh, perform a concise rewrite that incorporates current learnings.
  • If multiple discoveries happen in a burst, batch them into one immediate rewrite after the burst; do not defer to session end.
How to Update

Rewrite the relevant sections of the document in place. The entire document should read as a coherent narrative at any point in time. Old theories that were superseded should be briefly noted as pivots ("Initially the hypothesis was X, but Y revealed that Z"), not deleted entirely — the evolution of understanding is part of the theory.

Keep the document concise. Prefer clarity over completeness. A reader should be able to understand the full strategic picture in under 5 minutes.

Document Structure

THEORY.MD should flow as natural prose organized under a few clear headings. The exact structure should adapt to the work, but a typical shape:

markdown
# Theory: [Short Title of the Work]

## Problem

[What problem exists, why it matters, what makes it hard. Not just symptoms
but the structural reason the problem exists.]

## Operating Theory

[Current mental model. How does the system actually work in the relevant area?
What are the key dynamics? Where is the leverage?]

## Strategy

[The systematic approach. Not tasks but principles. Why this sequence? What
connects the individual changes into a coherent campaign?]

## Key Discoveries

[Pivots in understanding. What was learned that changed direction. Brief but
specific — not "found a bug" but "the formula translator was re-parsing
identical ASTs 415K times because the cache key included per-cell context,
making the cache effectively useless."]

## Open Questions

[What remains uncertain. Where the current theory might break. What evidence
would change the approach.]

Tone

Write as a thoughtful engineer explaining their mental model to a peer. Direct, specific, no filler. Use concrete examples from the codebase. Avoid hedging language — state the theory clearly, and separately note where confidence is low.

Practical Rules

  • One THEORY.MD per repo, at repo root (THEORY.MD).
  • Maximum ~200 lines. If longer, tighten the prose.
  • Rewrite holistically, never append.
  • Update when theory changes, not when code changes.
  • Stay active for the whole session once activated.
  • Prefer frequent concise rewrites over infrequent large rewrites.
  • If the session remains trivial (one-liner fix, config change), stay active but no-op the document creation/update requirement.
  • If multiple workstreams are active, the theory should cover the primary one with brief notes on how others connect, not try to be comprehensive about everything.

© blader, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files in the repository root of blader/theorist.

  • SKILL.md
  • LICENSE
  • README.md

Open the folder on GitHubat commit 732d8d0

Compare with similar skills

Theorist next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Theorist compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Theorist this skillblader/theorist191—~1.7kAutomated safety check: PassMIT
Superset Agent Standupsuperset-sh/superset15k—~712Automated safety check: PassCustom licence
AgentRQ Workspace Agentagentrq/agentrq1.1k—~1.9kAutomated safety check: PassAGPL-3.0
Markdown Task Managerioniks/MarkdownTaskManager535—~2.2kAutomated safety check: PassMPL-2.0
Pi Messenger Crewnicobailon/pi-messenger720—~3.7kAutomated safety check: PassNone
Codekanban CLIfy0/CodeKanban225—~2.7kAutomated safety check: PassApache-2.0

Similar skills

  • Superset Agent Standup

    superset-sh/superset

    Sweeps every Superset workspace, task and agent terminal to report what finished, what needs review and what is blocked, read-only, and can publish the digest as a page.

    15k GitHub stars~712 tokensUpdated today
    Productivity & AutomationAuto-check passed
  • Guides a workspace agent through executing assigned tasks, replying to a remote human operator, and creating sub-tasks, memory and events inside an AgentRQ workspace.

    1.1k GitHub stars~1.9k tokensUpdated today
    Productivity & AutomationAuto-check passed
  • Markdown Task Manager

    ioniks/MarkdownTaskManager

    A skill your agent uses when managing tasks, the system is a Kanban task manager based on local Markdown files (kanban.md and archive.md).

    535 GitHub stars~2.2k tokensUpdated 3 mo ago
    Productivity & AutomationAuto-check passed
  • Pi Messenger Crew

    nicobailon/pi-messenger

    Orchestrator reference for pi-messenger Crew planning, task management, configuration, and agent coordination.

    720 GitHub stars~3.7k tokensUpdated 1 mo ago
    Productivity & AutomationAuto-check passed
  • Codekanban CLI

    fy0/CodeKanban

    Operate CodeKanban workflows, terminal sessions, and web sessions through the installable codekanban-cli command.

    225 GitHub stars~2.7k tokensUpdated 5 days ago
    Productivity & AutomationAuto-check passed
  • Kanban Video Orchestrator

    Luciole-Studio/Misaka-Agent

    Plan and run multi-agent video production pipelines. An agent skill from Luciole-Studio/Misaka-Agent.

    158 GitHub starsUsed in 2 repos~2.4k tokens
    Productivity & AutomationAuto-check: notes

Questions about Theorist

What does Theorist do?

Maintain a per-repo THEORY.MD as a continuously updated narrative of the operating theory behind the current work. Theorist is an agent skill from blader/theorist.MD as a continuously updated narrative of the operating theory behind the current work.

When should I use Theorist?

Theorist fits situations like: tasks that involve Task management.

How do I install Theorist in Claude Code?

Run `npx skills add blader/theorist --skill theorist -a claude-code`. Or copy the skill folder (the blader/theorist repository) into .claude/skills/theorist in your project. Claude Code loads it when a task matches its description.

How do I install Theorist in Codex?

Run `npx skills add blader/theorist --skill theorist -a codex`. Or copy the skill folder (the blader/theorist repository) into .agents/skills/theorist in your project. Codex loads it when a task matches its description.

Can I use Theorist in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add blader/theorist --skill theorist -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/theorist, .gemini/skills/theorist, .github/skills/theorist and .opencode/skills/theorist in your project.

What does Theorist need to run?

SKILL.md names no scripts, command-line tools or credentials: Theorist is instructions for the agent only.

Does Theorist access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Theorist safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Theorist use?

Theorist is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Theorist use?

About 1.7k tokens (SKILL.md is roughly 6.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Theorist?

Skills that share tags, products or a category with Theorist: Superset Agent Standup (superset-sh/superset, 15k stars), AgentRQ Workspace Agent (agentrq/agentrq, 1.1k stars), Markdown Task Manager (ioniks/MarkdownTaskManager, 535 stars) and Pi Messenger Crew (nicobailon/pi-messenger, 720 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Theorist?

blader (a GitHub user) maintains it in blader/theorist, which has 191 GitHub stars. The repository was last updated on February 28, 2026.

Source: blader/theorist on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.