Finishing a Development Branch
obra/superpowers
Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.
Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init.
$ npx skills add techygarg/lattice --skill refiners-update -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install techygarg/lattice refiners-update --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/refiners-update .claude/skills/refiners-update && rm -rf skills-srcUse ~/.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/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .claude/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/techygarg/lattice/tree/main/skills/refiners-updateType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add techygarg/lattice --skill refiners-update -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install techygarg/lattice refiners-update --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/refiners-update .agents/skills/refiners-update && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .agents/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add techygarg/lattice --skill refiners-update -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install techygarg/lattice refiners-update --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/refiners-update .cursor/skills/refiners-update && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .cursor/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/techygarg/lattice.git --path skills/refiners-update--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add techygarg/lattice --skill refiners-update -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install techygarg/lattice refiners-update --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/refiners-update .gemini/skills/refiners-update && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .gemini/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install techygarg/lattice refiners-updateInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add techygarg/lattice --skill refiners-update -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/refiners-update .github/skills/refiners-update && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .github/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add techygarg/lattice --skill refiners-update -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install techygarg/lattice refiners-update --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/techygarg/lattice.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/refiners-update .opencode/skills/refiners-update && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "refiners-update" agent skill from https://github.com/techygarg/lattice/tree/main/skills/refiners-update into .opencode/skills/refiners-update/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "refiners-update", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
refiners-updateUpdate existing Lattice standards after a significant change — the update-mode counterpart to lattice-init.
Refiners Update is an agent skill from techygarg/lattice. Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init. Scans .lattice/standards/, asks what changed, and routes each affected standard to its refiner's revise mode, recording a git-native change note. Use when the user says 'update refiners', 'refiners update', 'our standards changed', 'update our standards', 'the architecture changed, update the standards', 'we switched languages, update the standards', 'revise standards after a big change', or 're-run the…
Its SKILL.md is about 2.2k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Development. It works with Git. The repository describes itself as: Install engineering discipline into any AI coding assistant. Composable skills for design, implementation, review, and team standards. Better process, not just better prompts. The licence is MIT.
5 steps, taken from the step headings in SKILL.md.
Read from SKILL.md and the folder at commit 4d6c35f. It shows what the files ask for, not the result of running them.
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.
Shell commands in SKILL.md call:
gitFrom the folder's file list and the shell code blocks in SKILL.md.
No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.
From URLs in SKILL.md, links to its own repository left out.
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Refiners Update loads about 2.2k tokens when it runs. Until then it costs about 135 tokens; SKILL.md has 1,045 words of instructions outside code blocks.
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.
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); files beside SKILL.md are not scanned.
The full file from techygarg/lattice at commit 4d6c35f, republished under its MIT licence (© techygarg). 1,045 words, ~2,170 tokens.
.claude/skills/refiners-update/SKILL.md (or your agent's skills folder).The update-mode counterpart to lattice-init. Where lattice-init detects missing standards and routes you to refiners to create them, this molecule detects existing standards and routes you to each refiner's revise mode to update them after a significant change — then records what changed and why.
It orchestrates the refiners; it never reimplements their interviews. Versioning is git-native: history lives in commits, and each revised document gets a one-line change note. No version numbers are introduced.
Read, apply:
framework:knowledge-priming -- Load project context. Understand what the project is and how the code has drifted from the current standards (always).lattice-init + the relevant refiner), reimplement any refiner's interview, or introduce version numbers.If the change requires a standard that does not exist yet (e.g. the team just adopted DDD but there is no ddd-principles.md), that is creation — direct the user to /lattice-init or the relevant refiner to create it, and note it in the summary.
Standards doc (in .lattice/standards/) | Refiner to revise it | Config key |
|---|---|---|
knowledge-base.md | /knowledge-priming-refiner | paths.knowledge_base |
language-idioms.md | /language-idioms-refiner | paths.language_idioms |
architecture.md | /architecture-refiner | paths.architecture |
ddd-principles.md | /ddd-refiner | paths.ddd_principles |
clean-code.md | /clean-code-refiner | paths.clean_code |
review-standards.md | /review-refiner | paths.review_standards |
requirement-standards.md | /requirement-forge-refiner | paths.requirement_standards |
Maintainer note: This table mirrors the refiner inventory. When a refiner is added or removed, update this table (and
lattice-init's refiner list).skill-alignflags inventory drift across docs.
Read .lattice/config.yaml. For each row in the map above, resolve the path (use the config key's value if set, otherwise the default .lattice/standards/{file}) and check whether the document exists. For each existing document, read its footer to note the current mode (overlay/override) and any prior "Last updated" line.
Present the result:
## Current Standards
- knowledge-base.md: [exists (overlay, last updated 2026-05-02) / not found]
- language-idioms.md: [exists / not found]
- architecture.md: [exists / not found]
- ddd-principles.md: [exists / not found]
- clean-code.md: [exists / not found]
- review-standards.md: [exists / not found]
- requirement-standards.md: [exists / not found]STOP: If no .lattice/config.yaml exists, or no standards documents are found: there is nothing to update. Tell the user: "No existing standards found. Run /lattice-init to create them first." Do not proceed.
Ask the user what changed and why — in one or two sentences. This is the trigger. It becomes the change note recorded on each revised document and drives which standards are affected.
If the answer describes more than one distinct change (e.g. an architecture shift and a language switch together), capture each as its own short reason instead of one merged sentence. Each affected standard's change note (Step 4) must carry only the reason(s) that actually apply to it — a doc should never be stamped with a reason for a change that did not touch it.
Prompt with the common change types if the user is unsure:
From the trigger, propose which existing standards are likely affected and why. Present the proposed set with reasoning; do not silently decide the scope.
| Change type | Likely-affected standards |
|---|---|
| Architecture shift | architecture.md; review-standards.md if it gates on architecture rules |
| Language / framework change | language-idioms.md; clean-code.md if limits are language-specific |
| Domain rules | ddd-principles.md; architecture.md if the domain layer's placement changed |
| Review / quality policy | review-standards.md; clean-code.md |
| Project identity / stack / layout | knowledge-base.md |
| Requirement / spec policy | requirement-standards.md |
| A learning promoted to a standing rule | whichever standard the rule belongs to — clean-code.md, review-standards.md, or architecture.md |
Ask the user to confirm or adjust the set before proceeding. Only documents that actually exist (from Step 1) are eligible — for anything that should change but does not exist yet, follow the creation note above.
If Step 2 captured more than one distinct change, tag each affected standard with which of those change(s) justifies its inclusion — a doc can be justified by more than one. Carry this doc-to-reason tagging into Step 4; it determines what each doc's change note says.
Execution model: You — the AI running this molecule — drive each revision yourself: load and apply the refiner skill's revise flow as part of this molecule's execution, then return here to append the change note before moving to the next standard. Do not hand control back to the user and end your turn between revising and noting — the change note is this molecule's responsibility and must be written while you still hold control. (If a refiner is instead run as a separate session, the note will be missed — re-invoke /refiners-update afterward; its idempotent re-scan re-detects the revised document so the note still gets recorded.)
For each confirmed standard, in the order it appears in the map:
Offer the choice: Revise now, Skip, or Skip all remaining.
On Revise now: apply the corresponding refiner's revise path — its own "Check for existing documents → Revise" flow, which loads the existing document and updates only the sections the change touched. Reference and apply the refiner skill; do not copy its interview here. Tell the user: "Applying {refiner} in revise mode to update {doc}."
When the refiner's revision completes and control returns here, append (or update) the change note as the final line of the document's existing footer, matching the footer's own plain-italic style (*...*) — not a blockquote:
*Last updated: {YYYY-MM-DD} — {this doc's tagged reason(s) from Step 3}*Use the current date, and only the reason(s) tagged to this specific doc — not the full multi-change text from Step 2 when other captured changes did not touch it. If a prior "Last updated" line exists, replace it with the new one.
On Skip: move to the next standard. On Skip all remaining: jump to Step 5.
Report:
## Standards Updated
- [doc]: revised — [one-line reason]
- [doc]: skipped
- [doc]: needs creation — run /{refiner} (did not exist)Remind the user:
git log carries the "when".chore(standards): revise architecture + review after move to CQRS).This molecule is idempotent and re-runnable. It owns no living document of its own — every invocation re-scans the current state in Step 1, so running it again after a partial pass simply re-detects what exists and what changed. There is no partial-session document to resume.
© techygarg, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Just SKILL.md in skills/refiners-update of techygarg/lattice.
Open the folder on GitHubat commit 4d6c35f
Refiners Update 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.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Refiners Update this skilltechygarg/lattice | 198 | — | ~2.2k | Automated safety check: Pass | MIT | |
| Finishing a Development Branchobra/superpowers | 296k | 5 repos | ~1.9k | Automated safety check: Pass | MIT | |
| Code Review ChecklistshareAI-lab/learn-claude-code | 78k | 5 repos | ~1.1k | Automated safety check: Pass | MIT | |
| Codebase Knowledge Graph Q&AEgonex-AI/Understand-Anything | 86k | 1 repos | ~1.2k | Automated safety check: Pass | MIT | |
| Code Design Rationale Investigatorcursor/plugins | 10k | 9 repos | ~2.6k | Automated safety check: Pass | None | |
| Understand Diff AnalysisEgonex-AI/Understand-Anything | 86k | 1 repos | ~1.4k | Automated safety check: Pass | MIT |
obra/superpowers
Walks the last step of a branch: confirm tests pass, detect the git environment, ask how to integrate, carry out your choice and clean up the worktree.
shareAI-lab/learn-claude-code
Reviews code against a five-part checklist covering security, correctness, performance, maintainability and testing, and reports findings in a fixed format.
Egonex-AI/Understand-Anything
Answers questions about a codebase by searching a prebuilt knowledge graph of its files, functions, classes and dependencies, not by rereading every source file.
cursor/plugins
Digs into why code is shaped the way it is by checking git history, pull requests and connected tools in parallel, then reporting a cited read on the tradeoffs.
Egonex-AI/Understand-Anything
Reads your git changes or a pull request against a prebuilt knowledge graph of the project to explain what changed, which components are affected and what is risky.
Egonex-AI/Understand-Anything
Gives an in-depth explanation of one file, function or module by reading the project's knowledge graph and checking that the graph is still fresh.
techygarg/lattice
Architectural thinking partner for an existing repository — scans the codebase, conducts a structured interview, agrees on current architectural state and recommended direction, and produces a…
techygarg/lattice
Guided setup and upgrade-check experience for Lattice projects -- scans the repository, detects existing configuration and outdated conventions, suggests refiners and available upgrades in priority…
techygarg/lattice
Audit and fix all Lattice documentation, README, docs/, PROJECT.md, GitHub issue templates, and CLAUDE.md to ensure they are fully aligned with the current skill inventory.
techygarg/lattice
Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners.
techygarg/lattice
Facilitate a structured conversation to define architecture principles for a repository.
techygarg/lattice
Facilitate a structured conversation to define clean code principles for a repository.
Works with
Categories
Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init. Refiners Update is an agent skill from techygarg/lattice. Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init.
Refiners Update fits situations like: the user says update refiners; refiners update; our standards changed; update our standards.
Run `npx skills add techygarg/lattice --skill refiners-update -a claude-code`. Or copy the skill folder (skills/refiners-update in techygarg/lattice) into .claude/skills/refiners-update in your project. Claude Code loads it when a task matches its description.
Run `npx skills add techygarg/lattice --skill refiners-update -a codex`. Or copy the skill folder (skills/refiners-update in techygarg/lattice) into .agents/skills/refiners-update in your project. Codex loads it when a task matches its description.
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add techygarg/lattice --skill refiners-update -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/refiners-update, .gemini/skills/refiners-update, .github/skills/refiners-update and .opencode/skills/refiners-update in your project.
Going by SKILL.md and its folder, Refiners Update needs the command-line tools its instructions call (git).
SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.
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. Review the folder before installing.
Refiners Update is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
About 2.2k tokens (SKILL.md is roughly 8.7k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
Skills that share tags, products or a category with Refiners Update: Finishing a Development Branch (obra/superpowers, 296k stars), Code Review Checklist (shareAI-lab/learn-claude-code, 78k stars), Codebase Knowledge Graph Q&A (Egonex-AI/Understand-Anything, 86k stars) and Code Design Rationale Investigator (cursor/plugins, 10k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
techygarg (a GitHub user) maintains it in techygarg/lattice, which has 198 GitHub stars. The repository holds 33 skills in this directory. The repository was last updated on October 6, 2026.
Source: techygarg/lattice on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.