Skill for your agent to manage very easily every issue
# Add to your Claude Code skills
git clone https://github.com/leonardoserra/local-contextGuides for using ai agents skills like local-context.
local-context is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by leonardoserra. Skill for your agent to manage very easily every issue. It has 1 GitHub star.
local-context's catalog security scan is still queued. You can run an instant dependency and prompt-injection check now with the "Scan for vulnerabilities" button above.
Clone the repository with "git clone https://github.com/leonardoserra/local-context" and add it to your Claude Code skills directory (see the Installation section above).
local-context is primarily written in Shell. It is open-source under leonardoserra on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh local-context against similar tools.
No comments yet. Be the first to share your thoughts!
Available after the catalog security scan passes.
⚠️ Third-Party Software Notice
This skill is third-party open-source software developed and hosted independently on GitHub. SkillsLLM lists this project for discovery and does not control or maintain the underlying repository.
Any security checks, ratings, or warnings displayed by SkillsLLM are automated and limited in scope. They do not constitute a security certification or guarantee that the software is safe, error-free, or free from malicious code, vulnerabilities, compromised dependencies, or prompt-injection risks.
Review the source code, permissions, dependencies, and configuration before installing or running any third-party skill. Use is at your own risk. To the maximum extent permitted by applicable law, SkillsLLM is not liable for losses arising from third-party software.
The deep catalog scan for this skill is still queued. Run an instant dependency check now instead.
A Claude Code plugin (and set of Agent Skills for any agent) that gives each feature its own working memory in
.local_context/<feature>/, so a later session can pick up exactly where the last one stopped.
| Folder | Holds |
|---|---|
_current/ |
what is true now: state, goal, scope, a § RESUME HERE section; one file per decision (_decisions/) and per open question (_questions/) |
_implementation_plan/ |
the ordered work: a Tasks table (status lives there), one file per task with anchors and a Done when line, verification commands, a "Do NOT do (YAGNI)" table |
_archive/ |
dated history, one entry per file (YYYY_MM_DD/N.md), append-only |
_business/ (optional) |
the feature's business rules only (scope, who gets/sees what, data, timing), one file per theme, whoever decided them; not created for pure technical work such as a bug fix |
_crm/ (optional) |
the code review mapping: a reading map of the feature's changed files, one file per functionality group with each repo's files side by side; derived from the branches and regenerated, never edited by hand |
.local_context/ is git-ignored automatically and never committed.
Folders are flat, one per feature. Ask for a feature inside another one (e.g. a feature split into subtasks) and it is
nested: the parent's _current/ holds what the subtasks share. A feature spanning several repos gets a folder of the
same name in each repo, each scoped to its repo and pointing at the others by path:line instead of copying them.
Feature names never start with _.
The folders follow ICM, Interpretable Context Methodology (paper, reference
implementation RinDig/Interpretable-Context-Methodology).
local-context takes the idea and implements it in its own workflow; it is not a copy of that repo. Each part made of
several pieces is a folder starting with _, one file per piece, and a short STATE.md index in each. An agent reads
down the layers (skill, ICM.md, the indexes, then only the piece files it needs) and stops when it has what it needs.
STATE.md holds every status (task, question, review mark); files are never renamed, order lives in the index.
Measured cost against 2.0.0 (instructions plus the record read):
continue, business-questions and tidy..local_context/<feature>/
_current/STATE.md state as of a date, goal, scope, where it stands, RESUME HERE
_current/_decisions/STATE.md | # | File | Decision | Date | Who |
_current/_decisions/01_<slug>.md
_current/_questions/STATE.md | # | File | Question | Status | open | answered <date> → decision
_current/_questions/01_<slug>.md
_implementation_plan/STATE.md START HERE, | # | File | Task | Depends on | Status |, Blocked, Verification, YAGNI
_implementation_plan/01_<slug>.md
_archive/STATE.md | Entry | Commits | Title | oldest first; read the tail
_archive/2026_11_16/1.md
_business/STATE.md | File | Theme | Rules | Last changed | Summary |
_business/<theme>.md
_crm/STATE.md map header, | # | File | Group | Status |
_crm/01_<slug>.md
.icm true (ICM) or false (old flat layout kept); written on the first run
The contract lives in skills/local-context-new/: ICM.md (layers, paths, rules),
ICM_OPS.md (operations), ICM_FORMATS.md (every format), both read one section at a time. Migrating a flat folder
lives in its own skill, local-context-icm-migrate, read only when a folder is migrated.
All skills are user-invoked only (the agent never triggers them on its own).
Every skill name starts with local-context-, so it stays unique in agents that have no plugin namespace.
| Agent | How to call a skill |
|---|---|
| Claude Code (plugin) | /local-context:local-context-new … |
| Codex | $local-context-new … |
| Others (OpenCode, Hermes, OpenClaw, …) | by name: local-context-new …, or the agent's own skill syntax |
| Skill | What it does |
|---|---|
local-context-new <description> |
Creates .local_context/<feature>/ in the ICM layout, filled in from your description |
local-context-continue [feature | free text] |
Resumes a feature: reads its state, checks it against git log, agrees session rules, then works the plan task by task, keeping the files up to date |
local-context-start <description> |
local-context-new followed by local-context-continue, in one step |
local-context-tidy [feature] |
Audits and cleans a feature folder: moves history from the current state into the archive word for word (checked with cmp), makes the plan match git, and checks every STATE.md index against its folder |
local-context-business-questions [feature | free text] |
Checks where a feature really stands (docs vs git, code and ticket), builds with you the list of decisions only the business can take (skipping anything the code or project docs already answer), posts it bilingual on the ticket, and records the answers in _business/ |
local-context-code-review-mapping [feature | free text] |
Writes _crm/: every file the feature's branches change (across a container repo and its submodules), grouped by functionality with each repo's files together and ordered for reading, so a merge request too large to review file by file can be read one chunk at a time. Checks that every changed file is mapped |
local-context-icm-migrate [feature] |
Migrates a flat pre-3.0.0 feature folder to the ICM layout, with every folder the feature spans (parent, sub-features, same-name folders in other repos), without asking anything: every piece cut with sed and proved with cmp, every unusual shape decided by fixed rules, pointers rewritten, one report at the end. The other skills run it when you pick Migrate in their layout check |
local-context-code-review-navigator <feature> [group] [ide] (alias local-context-crn) |
Reviews _crm/ one group at a time, like a small merge request: explains per repo what the group's changes do (files and path:line included) and flags wrong patterns or business-rule mismatches, adds <xplain> … </xplain> reading notes in the code, then opens the IDE you name (it finds its launcher) in one window on a throwaway worktree per repo where every file is at the branch head and only that group's changes are staged, printing that command for you to copy. Answers questions, makes edits and handles <crn> … </crn> (code-review-note) comments you leave in the code, then on your OK applies the edits (uncommitted) to the feature branch checkout and opens the next group |
Examples (Claude Code):
/local-context:local-context-new the new task is called axum migration, it moves the HTTP server from actix-web to axum
/local-context:local-context-continue axum_migration. Mandatory skills: caveman for exploration, ponytail for code.
/local-context:local-context-tidy axum_migration
/local-context:local-context-code-review-mapping axum_migration
/local-context:local-context-crn axum_migration
local-context-continue offers the optional caveman and ponytail
skills if you have them installed; it works fine without them. If a project's CLAUDE.md defines its own
.local_context/ rules, those take precedence.
Two skills turn a merge request too big to read file by file into small reviews, one functionality at a time. They work across a container repo and its submodules, e.g. a backend and a frontend changed together.
/local-context:local-context-code-review-mapping <feature>
Writes .local_context/<feature>/_crm/: every file the feature's branches change, grouped by the
capability it implements (each repo's files side by side under the repo name, specs with the code they test), in
reading order, foundations first. A group with many files (around 10 in one repo) is split into subgroups when its
files hold ideas that read separately (e.g. Report templates / CSV export); one idea stays one group. Lockfiles,
generated files and config are reviewed too, in a last Other / mechanical group, or several by domain (e.g.
Other / mechanical — dependencies) when one is too big to follow mixed. Each group has a Read for: hint, a Context: line pointing at the code outside the group it relies on (callers, inputs, constants, as path:line at the branch head), and one command per repo that opens all its files. A coverage check proves no
changed file is left out. Run it again whenever the branches move; never edit the map by hand.
/local-context:local-context-crn <feature> # every group not yet reviewed, from the first one
/local-context:local-context-crn <feature> 4 # only group 4
/local-context:local-context-crn <feature> 2 zed # name the IDE up front
local-context-crn is the short alias of local-context-code-review-navigator (crn = code-review-navigator).
The <crn> tag you write in the code (step 5 below) is a different thing: crn = code-review-note.
PATH, else from the web, else it asks
you for the path). Terminal editors such as Neovim get a command to run yourself.~/.cache/local-context-crn/, and opens all of
them in one IDE window, e.g. code "<worktree of repo 1>" "<worktree of repo 2>". It prints that