Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/.

MITAuto-check passedAgent Workflows

Install Gcc

skills CLI
$ npx skills add davila7/claude-code-templates --skill gcc -a claude-code

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

GitHub CLI
$ gh skill install davila7/claude-code-templates gcc --agent claude-code

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

Manual copy
$ git clone --depth 1 https://github.com/davila7/claude-code-templates.git skills-src && mkdir -p .claude/skills && cp -r skills-src/cli-tool/components/skills/git/git-context-controller .claude/skills/gcc && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

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

Facts

Skill name
gcc
GitHub stars
32k
Token cost
~1.6k tokens
SKILL.md length
758 words
Files
3 (incl. scripts, references)
Skills in repo
477
Repo updated
First seen
Licence
MIT

At a glance

Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/.

  • Works in 5 steps: Read the current branch's commit.md to… → Append a new entry to commit.md with → Append an OTA entry to log.md recording… → …
  • Natural language like commit this progress
  • SKILL.md covers Overview, Initialization, Configuration and Commands, plus 3 more sections
  • Runs Shell scripts from its folder

What it does

Gcc is an agent skill from davila7/claude-code-templates. Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/. This skill should be used when working on multi-step projects that benefit from structured memory persistence, milestone tracking, branching for alternative approaches, and cross-session context recovery. Triggers on /gcc commands or natural language like 'commit this progress', 'branch to try an alternative', 'merge results', 'recover context'.

Its SKILL.md is about 1.6k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including scripts and reference files (for example `references/file_formats.md` and `scripts/gcc_init.sh`).

It sits in Agent Workflows, covering Project management, Session handoff and Agent memory. It works with Git. The repository describes itself as: CLI tool for configuring and monitoring Claude Code. The licence is MIT.

When your agent uses it

  • Natural language like commit this progress
  • Branch to try an alternative
  • Recover context

Example prompts

  • “commit this progress”
  • “branch to try an alternative”
  • “merge results”
  • “/gcc”

Requirements

  • A Bash shell

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Read the current branch's commit.md to determine the next commit number
  2. Append a new entry to commit.md with
  3. Append an OTA entry to log.md recording the commit action
  4. Update metadata.yaml file tree if files were created/modified
  5. If on main branch, update milestones section in main.md

What it can do on your machine

Read from SKILL.md and the folder at commit 14680ec. 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

    Ships 1 file in scripts/ (Shell), which the agent can run.

    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

Gcc loads about 1.6k tokens when it runs, and up to ~2.4k if it reads all its reference files. Until then it costs about 111 tokens; SKILL.md has 758 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~111
When it runs · the whole SKILL.md, loaded when a task matches
~1.6k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~2.4k

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); the scripts in this folder are not scanned.

SKILL.md

The full file from davila7/claude-code-templates at commit 14680ec, republished under its MIT licence (© davila7). 758 words, ~1,636 tokens.

Download SKILL.mdSave it as .claude/skills/gcc/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
gcc
description
Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/. This skill should be used when working on multi-step projects that benefit from structured memory persistence, milestone tracking, branching for alternative approaches, and cross-session context recovery. Triggers on /gcc commands or natural language like 'commit this progress', 'branch to try an alternative', 'merge results', 'recover context'.

Git Context Controller (GCC)

Overview

GCC transforms agent memory from a passive token stream into a structured, versioned file system under .GCC/. Inspired by Git, it provides four operations — COMMIT, BRANCH, MERGE, CONTEXT — to persist milestones, explore alternatives in isolation, synthesize results, and recover historical context efficiently.

Initialization

On first use, check if .GCC/ exists in the project root. If not, run scripts/gcc_init.sh to create the directory structure:

.GCC/
├── main.md          # Global roadmap and objectives
├── metadata.yaml    # Infrastructure state (branches, file tree, config)
├── commit.md        # Commit history for main branch
├── log.md           # OTA execution log for main branch
└── branches/        # Isolated workspaces for experiments
    └── <branch-name>/
        ├── commit.md
        ├── log.md
        └── summary.md

For detailed file format specifications, read references/file_formats.md.

Configuration

GCC behavior is controlled via metadata.yaml:

  • proactive_commits: true — Automatically suggest commits after completing coherent sub-tasks
  • proactive_commits: false — Only commit when explicitly requested

Toggle with: "enable/disable proactive commits" or by editing metadata.yaml.

Commands

COMMIT

Persist a milestone on the current branch.

Triggers: /gcc commit <summary>, "commit this progress", "save this milestone", "checkpoint"

Procedure:

  1. Read the current branch's commit.md to determine the next commit number
  2. Append a new entry to commit.md with:
    • Sequential ID (e.g., [C004])
    • Date (UTC ISO 8601)
    • Current branch name
    • Branch purpose (from summary.md if on a branch, or from main.md)
    • Previous progress summary (1-2 sentences from last commit)
    • This commit's contribution (detailed technical description with files touched)
  3. Append an OTA entry to log.md recording the commit action
  4. Update metadata.yaml file tree if files were created/modified
  5. If on main branch, update milestones section in main.md

Proactive behavior: When proactive_commits: true, suggest a commit after:

  • Completing a function, module, or coherent unit of work
  • Fixing a bug and verifying the fix
  • Finishing a research/exploration phase with conclusions
  • Any point where losing context would mean re-doing significant work
BRANCH

Create an isolated workspace for exploring an alternative approach.

Triggers: /gcc branch <name>, "branch to try...", "explore alternative...", "experiment with..."

Procedure:

  1. Create .GCC/branches/<branch-name>/ directory
  2. Create summary.md with: purpose, parent branch, creation date, key hypotheses
  3. Create empty commit.md and log.md for the branch
  4. Update metadata.yaml to register the new branch
  5. Update main.md Active Branches section
  6. Log the branch creation in the parent branch's log.md

From this point, all COMMITs and OTA logs go to the branch-specific files until a MERGE or explicit branch switch.

MERGE

Integrate a completed branch back into the main flow.

Triggers: /gcc merge <branch>, "merge results from...", "integrate the experiment", "branch X is done"

Procedure:

  1. Read the branch's summary.md and commit.md to understand outcomes
  2. Append a synthesis commit to main's commit.md summarizing:
    • What was tried
    • What was learned
    • What is being integrated (or why the branch is being abandoned)
  3. Update main.md:
    • Add milestone entry with branch results
    • Remove from Active Branches
    • Update objectives if applicable
  4. Update metadata.yaml: set branch status to merged or abandoned
  5. Log the merge in main's log.md
Show full SKILL.md (315 more words)Show less
CONTEXT

Retrieve historical memory at different resolution levels.

Triggers: /gcc context <flag>, "what did we do on...", "recover context", "show me the history", "where were we"

Flags:

  • --branch [name] — Read summary.md and latest commits for a specific branch (or current branch if no name). Provides high-level understanding of what happened and why.

  • --log [n] — Read last N entries (default 20) from the current branch's log.md. Provides fine-grained OTA traces for debugging or resuming interrupted work.

  • --metadata — Read metadata.yaml to recover project structure: file tree, dependencies, active branches, configuration.

  • --full — Read main.md for the complete project roadmap, all milestones, and active branches. Use for cross-session recovery or handoff to another agent.

When no flag is specified, default to --branch for the current active branch.

OTA Logging

Throughout all work (not just during explicit commands), maintain the OTA execution log:

  1. Observation: What was noticed or discovered
  2. Thought: Reasoning about what to do next
  3. Action: What action was taken

Append entries to the active branch's log.md. Keep a maximum of 50 entries; when exceeding, remove the oldest entries. Each entry includes a sequential ID, timestamp, and branch name.

Log OTA entries at meaningful decision points — not every single action, but significant observations, strategy changes, and outcomes.

Cross-Session Recovery

When starting a new session on an existing project with .GCC/:

  1. Read metadata.yaml to understand project state and active branches
  2. Read main.md for the global roadmap and objectives
  3. Read the active branch's latest commits and log entries
  4. Resume work with full context of what was accomplished and what remains

Natural Language Mapping

User saysCommand
"save/checkpoint/persist this"COMMIT
"try a different approach"BRANCH
"that experiment worked, integrate it"MERGE
"where were we?" / "what's the status?"CONTEXT --full
"what happened on branch X?"CONTEXT --branch X
"show recent activity"CONTEXT --log
"what files do we have?"CONTEXT --metadata
"enable/disable auto-commits"Toggle proactive_commits in metadata.yaml

© davila7, 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 (scripts, references) in cli-tool/components/skills/git/git-context-controller of davila7/claude-code-templates.

  • SKILL.md
  • references/file_formats.md
  • scripts/gcc_init.sh

Open the folder on GitHubat commit 14680ec

Compare with similar skills

Gcc 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.

Gcc compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Gcc this skilldavila7/claude-code-templates32k—~1.6kAutomated safety check: PassMIT
Elite Longterm MemoryaAAaqwq/AGI-Super-Team1052 repos~2.9kAutomated safety check: PassMIT
Beads Task Memorygastownhall/beads28k—~1.2kAutomated safety check: PassMIT
Session History Searchslopus/happy24k—~3.1kAutomated safety check: PassMIT
Session Catchup and Handoffposhan0126/dotclaude871—~811Automated safety check: PassMIT
Session Handoff Writercodewhale-hq/Codewhale41k—~1.2kAutomated safety check: PassMIT

Similar skills

  • Elite Longterm Memory

    aAAaqwq/AGI-Super-Team

    Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot.

    105 GitHub starsUsed in 2 repos~2.9k tokens
    Agent WorkflowsAuto-check passed
  • Beads Task Memory

    gastownhall/beads

    Tracks multi-session work with dependencies in the bd issue tracker so the agent can find ready tasks and recover its context after conversation compaction.

    28k GitHub stars~1.2k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • Searches past Claude Code, Codex and Cursor sessions and summarizes what was worked on, tried or decided, using extraction scripts instead of reading raw logs.

    24k GitHub stars~3.1k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Session Catchup and Handoff

    poshan0126/dotclaude

    Rebuilds working context after /clear by reading a handoff note and the branch's git state, or writes that handoff note before a session ends.

    871 GitHub stars~811 tokensUpdated 1 mo ago
    Agent WorkflowsAuto-check passed
  • Session Handoff Writer

    codewhale-hq/Codewhale

    Writes a compact handoff note from real git and CI state so the next session or a teammate can pick up the work without rebuilding the context.

    41k GitHub stars~1.2k tokensUpdated today
    Agent WorkflowsAuto-check passed
  • File-Based Planning in Arabic

    OthmanAdi/planning-with-files

    Arabic edition of a file-based planning skill that keeps task_plan.md, findings.md and progress.md on disk so multi-step agent work survives lost context.

    27k GitHub stars~3.2k tokensUpdated 2 days ago
    Agent WorkflowsAuto-check: notes

More from davila7/claude-code-templates

All 477 skills in this repo
  • Perplexity Web Search

    davila7/claude-code-templates

    Runs web-grounded searches through Perplexity's Sonar models over OpenRouter for current events, recent literature and cited facts beyond the model's training cutoff.

    32k GitHub starsUsed in 12 repos~3.5k tokens
    Auto-check: notes
  • Neuropixels Data Analysis

    davila7/claude-code-templates

    Analyzes Neuropixels recordings from SpikeGLX or Open Ephys through preprocessing, drift correction, Kilosort4 spike sorting, quality metrics and curation.

    32k GitHub starsUsed in 10 repos~2.8k tokens
    Auto-check passed
  • Scientific Venue Templates

    davila7/claude-code-templates

    Supplies LaTeX templates and formatting rules for journals, conferences, posters, and grant proposals, then can check a draft against them.

    32k GitHub starsUsed in 9 repos~5.1k tokens
    Auto-check: notes
  • Brand Voice Content Creator

    davila7/claude-code-templates

    Analyzes a brand's existing writing to lock in a consistent voice, then builds SEO blog posts and platform-specific social content around it.

    32k GitHub starsUsed in 3 repos~1.9k tokens
    Auto-check passed
  • CAPA Officer

    davila7/claude-code-templates

    Guides corrective and preventive action (CAPA) work in a quality management system, from initiation and root cause analysis through effectiveness verification.

    32k GitHub starsUsed in 1 repo~2k tokens
    Auto-check passed
  • Fda Consultant Specialist

    davila7/claude-code-templates

    Senior FDA consultant and specialist for medical device companies including HIPAA compliance and requirement management.

    32k GitHub starsUsed in 1 repo~2.7k tokens
    Auto-check passed

Works with

Categories

Questions about Gcc

What does Gcc do?

Git Context Controller (GCC) - Manages agent memory as a versioned file system under .GCC/. Gcc is an agent skill from davila7/claude-code-templates.GCC/.

When should I use Gcc?

Gcc fits situations like: natural language like commit this progress; branch to try an alternative; recover context.

How do I install Gcc in Claude Code?

Run `npx skills add davila7/claude-code-templates --skill gcc -a claude-code`. Or copy the skill folder (cli-tool/components/skills/git/git-context-controller in davila7/claude-code-templates) into .claude/skills/gcc in your project. Claude Code loads it when a task matches its description.

How do I install Gcc in Codex?

Run `npx skills add davila7/claude-code-templates --skill gcc -a codex`. Or copy the skill folder (cli-tool/components/skills/git/git-context-controller in davila7/claude-code-templates) into .agents/skills/gcc in your project. Codex loads it when a task matches its description.

Can I use Gcc 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 davila7/claude-code-templates --skill gcc -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/gcc, .gemini/skills/gcc, .github/skills/gcc and .opencode/skills/gcc in your project.

What does Gcc need to run?

Going by SKILL.md and its folder, Gcc needs a shell for the scripts in its folder. Our summary lists: A Bash shell.

Does Gcc 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 Gcc 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. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Gcc use?

Gcc is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Gcc use?

About 1.6k tokens (SKILL.md is roughly 6.5k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 803 tokens, read only when the agent opens those files.

What are the alternatives to Gcc?

Skills that share tags, products or a category with Gcc: Elite Longterm Memory (aAAaqwq/AGI-Super-Team, 105 stars), Beads Task Memory (gastownhall/beads, 28k stars), Session History Search (slopus/happy, 24k stars) and Session Catchup and Handoff (poshan0126/dotclaude, 871 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Gcc?

davila7 (a GitHub user) maintains it in davila7/claude-code-templates, which has 32,463 GitHub stars. The repository holds 477 skills in this directory. The repository was last updated on October 8, 2026.

Source: davila7/claude-code-templates on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.