Systematic Toolchain for AI Research

STAR

Research, by design

A reusable foundation for reproducible, well-structured AI research — one predictable layout, one experiment entrypoint, and a fifteen-skill workflow that carries a vague idea all the way to a released repository, with every decision on file.

✦ Get Started View on GitHub
15Workflow Skills
4AI Agents Supported
2Languages · EN 中文
MITOpen Source

Why STAR

Everything in its place.
Every decision on file.

Research code rots when structure lives in someone's head and context lives in a chat window. STAR moves both into the repository itself.

A consistent layout

Code, data, weights, outputs, and methodology notes each have one predictable home — code/, datas/, inits/, wkdrs/, metds/.

A portable runtime boundary

Machine-specific paths live in a local .env, never in scripts. Clone the repo anywhere, point it at your conda or venv, and run.

One experiment entrypoint

bash execs/run.sh <exp> activates the environment, exports the path variables, and launches any experiment script the same way, every time.

A traceable, resumable research process

Plans live in metds/plans/, execution intermediates in tasks/, run artifacts in wkdrs/. Key decisions, task dependencies, and validation records persist in project files — not in chat history — so any session, human or agent, can pick up exactly where the last one stopped.

AI-agent native

Shared instructions and identical skill sets ship for Codex, Claude, Kimi, and Cursor — in English and Chinese. Your agents follow the same conventions you do, and STAR stays framework-agnostic: bring your own model stack, dependency manager, and experiment tracker.

Safe defaults for large artifacts

Local data, model weights, generated outputs, and environment settings are excluded from version control out of the box. Adopt an existing project with symlinks — nothing gets moved, nothing gets overwritten.

Upgradeable without disruption

bash execs/update.sh syncs newer STAR skills and workflow guides into an existing project without touching your code, experiments, or Git remotes.

Project structure

Eight directories.
Zero guessing.

The abbreviated names are deliberate: short to type, unambiguous to search, and identical across every STAR project you will ever open.

tree ~/my-research
STAR/ ├── code/ # core source (named by CODE_NAME) ├── datas/ # datasets & data files ├── inits/ # weights & checkpoints ├── metds/ # methodologies │ ├── ideas/ # topic explorations │ ├── plans/ # research plans & sub-plans │ └── refs/ # related-work notes + reference.bib ├── execs/ # executions │ ├── run.sh # ← the single entrypoint │ ├── update.sh │ └── scpts/ # experiment scripts ├── tasks/ # per-plan execution intermediates ├── wkdrs/ # run outputs: logs, metrics, figures ├── docs/ # documentation site ├── .env # machine-local paths (never committed) └── AGENTS.md # shared human + agent instructions
datas/Data — raw, processed, or generated datasets
inits/Initializations — pretrained weights and checkpoints
metds/Methodologies — plans, design notes, research records
execs/Executions — launchers and experiment scripts
scpts/Scripts — individual runnable experiment definitions
tasks/Tasks — each plan's tool scripts and working files
wkdrs/Work directories — logs, metrics, predictions, artifacts

Research workflow

Fifteen skills.
One constellation.

From a vague interest to a released repository — each skill writes its evidence into project files, so the whole research programme is auditable and resumable at any point.

✦

ShapeConverge on a topic and turn it into verifiable plans.

$star-proj-adopt

Adopt an already-started project without disturbing it — probe, symlink, record.

$star-idea-storm

Converge a vague interest into a defensible research topic, scored on six dimensions.

$star-plan-coach

Clarify the idea through staged questions into a strategic research plan.

$star-refs-reviewer

Survey related work into analysis notes and a verified, classified bibliography.

✦

BuildStand up the codebase and the runtime it needs.

$star-code-architect

Bootstrap the codebase from a scored reference implementation and record the architecture.

$star-env-builder

Build the conda env or venv from .env, resolve dependencies, smoke-verify.

$star-plan-decomposer

Split strategic plans recursively into verifiable, executable sub-plans.

✦

ExecuteImplement each leaf plan and audit what it produced.

$star-plan-executor

Implement and lightly validate one executable leaf plan, logging every run.

$star-code-reviewer

Review code against project conventions and the plan's promised implementation.

$star-expt-analyst

Audit a run against what the plan expected: artifacts, logs, metrics, meaning.

✦

SteerKeep the plan tree honest against execution evidence.

$star-plan-reviser

Revise a plan in place against its execution evidence, with a revision history.

$star-expt-digest

Summarize what the programme has done lately — verdicts, movement, gaps.

$star-flow-status

Report progress across the whole flow and the single next action to take.

✦

DeliverTurn matured plans into papers and releases.

$star-metd-summarize

Compile the plan tree into paper-ready method documents, flagging the unverified.

$star-code-release

Prepare the repository for release: promote code, polish, compile the README, sweep for secrets.

STAR research workflow: thirteen skills in running order plus two that read across them, what each writes, and how the per-leaf loop closes
The full workflow map — running order, outputs, and how the per-leaf loop closes.

Quick start

Six commands to liftoff.

Start fresh from the template — or run update.sh --adopt inside an existing repository and STAR installs itself around your work without moving a single file.

zsh — my-research
# 1 · Start a project from the STAR template ❯ git clone https://github.com/wanghao9610/STAR my-research && cd my-research ❯ rm -rf .git .github && git init # drop STAR's history and its maintainer CI # 2 · Name your source package, then configure the local runtime ❯ mv code my_pkg ❯ cp .env.example .env && $EDITOR .env # CODE_NAME=my_pkg, then PYTHON_HOME (or CONDA_HOME + ENV_NAME) # 3 · See what's runnable ❯ bash execs/run.sh --list # 4 · Launch through the single entrypoint — 00_exp prints the resolved paths ❯ bash execs/run.sh 00_exp ❯

Ready when you are

Give your research a
structure worth returning to.

STAR is free, MIT-licensed, and framework-agnostic. Use it as a GitHub template, or adopt it into the project you already have.

✦ Use the Template Read the Docs