alexeykrol/claude-code-starter — Summary

alexeykrol/claude-code-starter (v6.1.0) is a Russian-language Claude Code starter framework that auto-detects whether a project is code, content, or hybrid type and installs a matching skill/agent set. The framework features a single-file installer (init-project.sh), 6 skills, 3 agents, 4 hooks (PreCompact, PostCompact, PostToolUse, SubagentStop), a SNAPSHOT.md persistent session state file, and a repo_access system for controlling git history visibility (private-solo, private-shared, public). Version 6 introduced auto project-type detection — content projects (books, courses, knowledge bases) receive writer/editor/content-reviewer agents instead of code agents. The hook suite is unusual: it covers session lifecycle (pre/post compact for memory preservation) and subagent lifecycle (subagent-done fires on SubagentStop). The thinkingBudget: max setting in settings.json is a notable default.

differs_from_seeds: Closest to agent-os (installer-driven scaffold, markdown state files) and spec-driver (skill-heavy, session lifecycle hooks). Unique features not in seeds: auto project-type detection (code/content/hybrid), repo_access visibility modes, Russian-language documentation, and a pre/post compact hook pair for explicit memory preservation. The SNAPSHOT.md as a first-class persistent state file (not just CLAUDE.md) is architecturally similar to claude-conductor's memory pattern but more structured and explicitly synchronized.

alexeykrol/claude-code-starter — Overview

Origin

Russian-language Claude Code starter by alexeykrol. 180 GitHub stars, no license, Shell language classification. Last pushed 2026-04-27. 2 contributors.

Philosophy (translated from Russian)

The README opens with the problem statement:

"Usually when working with an agent, the project quickly falls apart: instructions live in one long CLAUDE.md; rules are mixed with project context; starting a new project and migrating an old one is done differently; agent memory is lost between sessions; internal framework files accidentally end up in shared/public git history."

The solution is:

• Separate project passport (CLAUDE.md) from operational logic (rules/skills/agents/hooks)
• Standard .claude/ directory structure
• Reusable workflows via skills
• Background guardrails via hooks
• Single-file installation
• repo_access control so agent memory doesn't leak where it shouldn't

Version 6 Innovation: Project Type Auto-Detection

"Version 6 introduced automatic project type detection (code / content / hybrid). Content projects — books, courses, knowledge bases, documents, transcripts — get their own set of rules, skills, and agents (writer, editor, content-reviewer). Installation without flags: bash init-project.sh itself figures out where it is and installs the appropriate layer."

This distinguishes code-oriented projects (implementer, researcher, reviewer agents) from content-oriented projects (writer, editor, content-reviewer agents).

Target User

Russian-speaking developers who want a well-structured Claude Code setup with explicit session state management and git-history control.

alexeykrol/claude-code-starter — Architecture

Distribution

Standalone GitHub repository with a single-file installer init-project.sh.

Install Method

# New project
chmod +x init-project.sh
bash init-project.sh

# Auto-detects: code / content / hybrid
# Installs appropriate skill/agent set

Directory Tree (installed into host project)

<host-project>/
├── .claude/
│   ├── rules/               (7 rule files)
│   │   ├── autonomy.md
│   │   ├── commit-policy.md
│   │   ├── context-management.md
│   │   ├── delegation.md
│   │   ├── local-first.md
│   │   ├── logging.md
│   │   └── production-safety.md
│   ├── skills/              (6 skills)
│   │   ├── db-migrate/
│   │   ├── finish/
│   │   ├── housekeeping/
│   │   ├── playwright/
│   │   ├── start/
│   │   └── testing/
│   ├── agents/              (3 agents)
│   │   ├── implementer.md
│   │   ├── researcher.md
│   │   └── reviewer.md
│   ├── hooks/               (4 hook scripts)
│   │   ├── post-compact.sh
│   │   ├── post-tool-checkpoint.sh
│   │   ├── pre-compact.sh
│   │   └── subagent-done.sh
│   ├── logs/
│   │   └── sessions/        (YYYY-MM-DD_HH-MM.md session logs)
│   ├── SNAPSHOT.md          (persistent session state)
│   └── settings.json        (hooks, thinkingBudget: max)
├── scripts/
│   ├── framework-state-mode.sh
│   └── switch-repo-access.sh
├── CLAUDE.md                (project passport)
├── manifest.md              (project_name, repo_access)
└── .gitignore

Required Runtime

• bash
• git
• Claude Code
• Recommended: python3 (for settings.json merge in migration flow)
• Optional: node/npm, pytest, sqlite3, psql, supabase

repo_access Modes

The switch-repo-access.sh script safely switches between modes, controlling which framework files appear in git history.

Config Files

• .claude/settings.json — hooks, thinkingBudget: max, permissions (allow all: Read, Edit, Write, Glob, Grep, Bash, WebSearch, WebFetch)
• manifest.md — project_name, repo_access
• .claude/SNAPSHOT.md — current session state

alexeykrol/claude-code-starter — Components

Skills (6)

• start/ — session initialization: reads SNAPSHOT.md, reads CLAUDE.md, checks git status, creates session log in .claude/logs/sessions/YYYY-MM-DD_HH-MM.md, reports status in 3-5 lines; uses disable-model-invocation: true (pure file reading, no LLM call)
• finish/ — session completion: updates SNAPSHOT.md, writes session summary, syncs state
• housekeeping/ — project maintenance: cleanup, organization
• testing/ — test execution workflow
• playwright/ — Playwright E2E testing integration
• db-migrate/ — database migration workflow

Agents (3, code mode)

• implementer.md — code implementation specialist
• researcher.md — read-only codebase exploration
• reviewer.md — code review specialist

(Content mode installs: writer.md, editor.md, content-reviewer.md instead)

Hooks (4)

PreCompact

• pre-compact.sh — runs before Claude Code context compaction; saves current session state to SNAPSHOT.md before memory loss

PostCompact

• post-compact.sh — runs after compaction; reloads state from SNAPSHOT.md; ensures context continuity

PostToolUse

• post-tool-checkpoint.sh (matcher: "", all tools) — periodic checkpoint after tool use; updates session logs

SubagentStop

• subagent-done.sh — fires when a subagent completes; coordinates back to main session

Rules (7)

• autonomy.md — controls agent autonomy level (what Claude can do without asking)
• commit-policy.md — git commit conventions and gates
• context-management.md — SNAPSHOT.md sync and context load rules
• delegation.md — when/how to delegate to implementer/researcher/reviewer agents
• local-first.md — prefer local operations over network calls
• logging.md — session logging conventions
• production-safety.md — safety checks before production operations

Scripts (2)

• scripts/framework-state-mode.sh — manages framework state persistence mode
• scripts/switch-repo-access.sh — switches between private-solo, private-shared, public repo access modes

Key Settings

{
  "thinkingBudget": "max",
  "permissions": {
    "allow": ["Read", "Edit", "Write", "Glob", "Grep", "Bash(*)", "WebSearch", "WebFetch"]
  }
}

Notable: thinkingBudget: max is the default — this maximizes extended thinking time for all operations.

alexeykrol/claude-code-starter — Uniqueness

differs_from_seeds

Closest to agent-os (installer-driven scaffold) but with substantially richer session lifecycle management. No seed implements auto project-type detection (code/content/hybrid) — this is a unique architectural choice that adapts the installed agent set to the project domain. The pre/post compact hook pair is the most explicit compaction handling in the batch; most seeds either ignore compaction (openspec, taskmaster-ai) or handle it partially (superpowers via memory). The repo_access system (private-solo/private-shared/public modes) addresses a real problem (framework files leaking into public git history) not addressed by any seed. The thinkingBudget: max default is the most aggressive thinking-budget setting in the batch. Russian-language documentation is a distinct market positioning choice.

Positioning

Structured, opinionated Russian-language starter with strong session lifecycle discipline. The SNAPSHOT.md + session logs pattern positions this as suitable for long-running projects with memory-critical workflows.

Observable Failure Modes

1. No license: No open-source license. Reuse rights unclear.
2. Permissive allow list: settings.json allows all Bash commands by default. Security responsibility falls entirely on the user.
3. Russian-only README: Non-Russian speakers cannot easily adopt the framework.
4. install-time detection: If a content project has some code files, the hybrid detection may install the wrong agent set.
5. post-tool-checkpoint overhead: Firing after every single tool use may add significant latency for rapid file-editing operations.

Cross-References

• README references official Anthropic Claude Code docs
• .claude/rules/ pattern is similar to spec-driver and superpowers
• Pre/post compact hooks unique to this batch