Customization Guide

Make the Clo-Author Yours

Overview

The Clo-Author works out of the box, but it’s designed to be customized. Six configuration layers control how Claude behaves in your project — from the high-level project constitution to low-level event hooks.

Layer	Location	Loaded When
CLAUDE.md	Project root	Every session
Rules	`.claude/rules/`	Always-on or path-scoped
References	`.claude/references/`	On demand (agents read when needed)
Skills	`.claude/skills/`	On demand (slash commands)
Agents	`.claude/agents/`	On demand (via skills or orchestrator)
Hooks	`.claude/settings.json`	On events (automatic)

Claude reliably follows about 100–150 custom instructions. Your system prompt uses ~50, leaving ~100 for your project. CLAUDE.md and always-on rules share this budget. Path-scoped rules, references, skills, and agents load on demand — they don’t count against the limit.

CLAUDE.md — The Project Constitution

CLAUDE.md is the single most important file. Claude reads it at the start of every session. It should be a slim constitution — short directives and pointers, not comprehensive documentation. Aim for ~120 lines:

Core principles — 5–6 bullets (plan-first, verify-after, quality gates, worker-critic pairs, auto-memory)
Folder structure — where everything lives
Commands — compilation, deployment
Skill quick reference — table of 10 available commands
Customization tables — Beamer environments, notation
Current state — what’s done, what’s in progress

Keep It Lean

If CLAUDE.md exceeds ~150 lines, Claude starts ignoring rules silently. Put detailed standards in path-scoped rules instead.

Rules — Auto-Loading Domain Knowledge

Rules are markdown files in .claude/rules/ that Claude loads automatically. Consolidated into 9 focused files for clarity.

Rule	Purpose
`workflow.md`	Plan-first protocol, orchestrator loop, dependency graph, standalone access
`quality.md`	Weighted scoring formula, severity gradient by phase, quality gates
`agents.md`	Worker-critic pairs, separation of powers, three-strikes escalation
`logging.md`	Session logging, session reporting, research journal
`content-standards.md`	Table generation, figure standards, PDF processing, exploration workflow
`content-invariants.md`	21 numbered non-negotiable rules (INV-1 through INV-21) for paper, code, and talks
`working-paper-format.md`	Working paper layout: 12pt, 1in margins, reference preamble (tabularray, cleveref, latexmk)
`revision.md`	R&R cycle comment classification and routing
`meta-governance.md`	Template vs working project distinction

Domain Profile

The domain profile (.claude/references/domain-profile.md) calibrates all agents to your specific research field. The default is economics. It can be adapted to adjacent fields (finance, accounting, marketing, management) by editing the profile. It can be populated two ways:

/discover (interactive interview) — generates it automatically
Manual editing — fill in the template directly

All agents read this file for:

Target journal tiers (for Orchestrator, Editor, and referees)
Common data sources (for Explorer)
Identification strategies (for Strategist and strategist-critic)
Field conventions (for Coder and Writer)
Seminal references (for Librarian)
Referee concerns (for domain-referee and methods-referee)

Journal Profiles

The journal profiles (.claude/references/journal-profiles.md) calibrate the Editor, domain-referee, and methods-referee to a specific journal’s review culture when you run /review --peer [journal].

30 journals are pre-populated across multiple fields:

Economics: AER, Econometrica, JPE, QJE, REStud, AEJ:Applied, AEJ:Policy, JHR, JHE, RAND, JPubE, JLE, JDE, RESTAT, AER:Insights
Finance: JF, JFE, RFS, JFQA
Accounting: JAR, JAE, TAR, CAR
Marketing: JMR, Marketing Science, JCR
Management: Management Science, SMJ, ASQ

Each profile describes the journal’s bar, what its referees prioritize, and typical concerns — in plain language that the LLM interprets naturally.

For journals not in the list, referees still adapt using the journal name + your domain profile. You can add your own profiles using the template at the bottom of the file.

Skills — Available Commands

Skills are multi-step workflows invoked with /command. Each skill lives in .claude/skills/[name]/SKILL.md and dispatches the appropriate agents.

There are 10 skills covering the full research pipeline: /new-project, /discover, /strategize, /analyze, /write, /review, /revise, /talk, /submit, and /tools.

Skills can be invoked two ways: explicitly (you type /review paper/main.tex) or automatically (Claude invokes them when relevant). Most of the time, you just describe what you want.

See the Command Reference for every command, flag, and subcommand. See the User Guide for detailed workflow descriptions.

Hooks — Smart Defaults

Hooks live in .claude/settings.json and fire on events, regardless of context state. Reduced to 5 hooks that stay out of the way.

Design Principles

Use command-based hooks for fast, mechanical checks
Use rules for nuanced judgment
Avoid prompt-based hooks that trigger LLM calls on every response

All 5 Hooks

Hook	Event	What It Does
File protection	`PreToolUse`	Blocks edits to bibliography and settings
Context state capture	`PreCompact`	Saves plan state + context survival checklist
Context restoration	`SessionStart[compact\\|resume]`	Restores context after compaction
Post-merge reminder	Git post-merge	Reminds to run `/tools learn` after merges
Auto-lint	`PostToolUse`	Lints R/Python/Julia files on every Edit or Write (advisory)

Memory System

Four persistent layers plus ephemeral conversation:

Layer	File	Updated When	Purpose
Project context	`CLAUDE.md`	Rarely	Project rules, folder structure
Corrections	`MEMORY.md`	Auto-memory (automatic)	Prevent repeating mistakes
Task strategy	`quality_reports/plans/`	Once per task	Plan survives handoff
Decision reasoning	`quality_reports/session_logs/`	Incrementally	Record why decisions were made
Conversation	Context window	Every response	Current working memory (not persistent)

Self-Improvement

Auto-Memory

Claude Code has a built-in memory system that automatically saves corrections and preferences across sessions. No manual tagging needed — when you correct Claude (“that’s UAB, not Emory”), it saves the correction and applies it in future conversations.

Memory is stored in .claude/projects/.../memory/ and persists across sessions. You can also explicitly ask Claude to remember or forget something.

Skill Extraction: /tools learn

For discoveries that deserve a reusable workflow (not just a one-liner correction), use /tools learn to create a full skill.

Situation	Use
Correction or preference	Auto-memory (automatic)
Multi-step workflow	`/tools learn` to create full skill

Exploration Workflow

The explorations/ folder provides a structured sandbox for experimental work.

The problem: Without structure, experimental code scatters across the repository.

The solution: All experimental work goes into explorations/ first:

explorations/
├── [active-project]/
│   ├── README.md           # Goal, hypotheses, status
│   ├── R/                  # Code iterations (_v1, _v2)
│   └── output/             # Results
└── ARCHIVE/
    ├── completed_[name]/   # Graduated to production
    └── abandoned_[name]/   # Documented why stopped

Fast-Track vs Plan-First

Question	Answer	Workflow
“Will this ship?”	YES	Plan-First (80/100 quality)
“Am I testing an idea?”	YES	Fast-Track (60/100 quality)
“Does this improve the project?”	NO	Don’t build it

Constitutional Governance (Optional)

Constitutional Governance

As your project grows, some decisions become non-negotiable. The templates/constitutional-governance.md template helps you distinguish between:

Immutable principles (Articles I–V): Non-negotiable rules
User preferences: Flexible patterns that can vary

Use it after you’ve established 3–7 recurring patterns.

Context Survival System

When context compaction happens, two hooks preserve and restore state:

%%{init: {'theme': 'dark', 'themeVariables': {'primaryColor': '#14142a', 'primaryTextColor': '#d0d0e0', 'primaryBorderColor': '#b44dff', 'lineColor': '#b44dff', 'secondaryColor': '#0c0c18', 'tertiaryColor': '#080810', 'edgeLabelBackground': '#080810'}}}%%
flowchart TD
    RUN[Session running]:::step -->|context fills up| PRE[PreCompact fires]:::hook
    PRE --> SAVE[Saves plan, task, decisions]:::step
    SAVE --> COMPACT[Auto-compaction happens]:::event
    COMPACT --> POST[SessionStart fires]:::hook
    POST --> RESTORE[Restores context summary]:::step
    RESTORE --> RESUME[Claude knows where it left off]:::approved

    classDef step fill:#14142a,stroke:#b44dff,color:#b44dff,stroke-width:2px
    classDef hook fill:#14142a,stroke:#00f0ff,color:#00f0ff,stroke-width:2px
    classDef event fill:#14142a,stroke:#ff2d7b,color:#ff2d7b,stroke-width:2px
    classDef approved fill:#14142a,stroke:#00cc66,color:#00cc66,stroke-width:2px