Agent skill

Refiners Update

by techygarg in techygarg/lattice

Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init.

MITAuto-check passedDevelopment

Install Refiners Update

skills CLI
$ npx skills add techygarg/lattice --skill refiners-update -a claude-code

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

GitHub CLI
$ gh skill install techygarg/lattice refiners-update --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/techygarg/lattice.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/refiners-update .claude/skills/refiners-update && 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
refiners-update
GitHub stars
198
Token cost
~2.2k tokens
SKILL.md length
1,045 words
Files
1
Skills in repo
33
Repo updated
First seen
Licence
MIT

At a glance

Update existing Lattice standards after a significant change — the update-mode counterpart to lattice-init.

  • Works in 5 steps: Scan existing standards → Capture what changed → Map the change to affected standards → …
  • The user says update refiners
  • SKILL.md covers Required Skills, What This Does (and does not), Refiner → standards document map and Workflow, plus 1 more section
  • Calls git

What it does

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.

When your agent uses it

  • The user says update refiners
  • Refiners update
  • Our standards changed
  • Update our standards

Example prompts

  • “update refiners”
  • “refiners update”
  • “our standards changed”
  • “/refiners-update”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Scan existing standards
  2. Capture what changed
  3. Map the change to affected standards
  4. Revise each affected standard
  5. Summary

What it can do on your machine

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

    Shell commands in SKILL.md call:

    • git

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    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.

  • 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

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.

Always · name and description, kept in context so the agent knows when to use it
~135
When it runs · the whole SKILL.md, loaded when a task matches
~2.2k

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); files beside SKILL.md are not scanned.

SKILL.md

The full file from techygarg/lattice at commit 4d6c35f, republished under its MIT licence (© techygarg). 1,045 words, ~2,170 tokens.

Download SKILL.mdSave it as .claude/skills/refiners-update/SKILL.md (or your agent's skills folder).
name
refiners-update
description
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 refiners'.

Refiners Update

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.

Required Skills

Read, apply:

  1. framework:knowledge-priming -- Load project context. Understand what the project is and how the code has drifted from the current standards (always).

What This Does (and does not)

  • Does: coordinate revising one or more existing standards documents after a change, and append a change note to each.
  • Does not: create standards that do not exist yet (that is 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.

Refiner → standards document map

Standards doc (in .lattice/standards/)Refiner to revise itConfig key
knowledge-base.md/knowledge-priming-refinerpaths.knowledge_base
language-idioms.md/language-idioms-refinerpaths.language_idioms
architecture.md/architecture-refinerpaths.architecture
ddd-principles.md/ddd-refinerpaths.ddd_principles
clean-code.md/clean-code-refinerpaths.clean_code
review-standards.md/review-refinerpaths.review_standards
requirement-standards.md/requirement-forge-refinerpaths.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-align flags inventory drift across docs.

Workflow

Step 1: Scan existing standards

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.

Step 2: Capture what changed

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:

  • Architecture shift (new layer, moved to CQRS, dropped a pattern)
  • Language or framework change
  • New or revised domain rules (aggregates, invariants)
  • New review or quality policy
  • Project identity / stack / directory layout change
  • A learning that should become a standing rule
Step 3: Map the change to affected standards

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 typeLikely-affected standards
Architecture shiftarchitecture.md; review-standards.md if it gates on architecture rules
Language / framework changelanguage-idioms.md; clean-code.md if limits are language-specific
Domain rulesddd-principles.md; architecture.md if the domain layer's placement changed
Review / quality policyreview-standards.md; clean-code.md
Project identity / stack / layoutknowledge-base.md
Requirement / spec policyrequirement-standards.md
A learning promoted to a standing rulewhichever 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.

Show full SKILL.md (382 more words)Show less
Step 4: Revise each affected standard

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:

  1. Offer the choice: Revise now, Skip, or Skip all remaining.

  2. 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}."

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

  4. On Skip: move to the next standard. On Skip all remaining: jump to Step 5.

Step 5: Summary

Report:

## Standards Updated
- [doc]: revised — [one-line reason]
- [doc]: skipped
- [doc]: needs creation — run /{refiner} (did not exist)

Remind the user:

  • History is git-native — there are no version numbers. The change note carries the "why"; git log carries the "when".
  • Commit the revised standards together with a message that names the change (e.g. chore(standards): revise architecture + review after move to CQRS).

Session behavior

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

Files

Just SKILL.md in skills/refiners-update of techygarg/lattice.

Open the folder on GitHubat commit 4d6c35f

Compare with similar skills

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.

Refiners Update compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Refiners Update this skilltechygarg/lattice198—~2.2kAutomated safety check: PassMIT
Finishing a Development Branchobra/superpowers296k5 repos~1.9kAutomated safety check: PassMIT
Code Review ChecklistshareAI-lab/learn-claude-code78k5 repos~1.1kAutomated safety check: PassMIT
Codebase Knowledge Graph Q&AEgonex-AI/Understand-Anything86k1 repos~1.2kAutomated safety check: PassMIT
Code Design Rationale Investigatorcursor/plugins10k9 repos~2.6kAutomated safety check: PassNone
Understand Diff AnalysisEgonex-AI/Understand-Anything86k1 repos~1.4kAutomated safety check: PassMIT

Similar skills

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

    296k GitHub starsUsed in 5 repos~1.9k tokens
    DevelopmentAuto-check passed
  • Code Review Checklist

    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.

    78k GitHub starsUsed in 5 repos~1.1k tokens
    DevelopmentAuto-check passed
  • Codebase Knowledge Graph Q&A

    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.

    86k GitHub starsUsed in 1 repo~1.2k tokens
    DevelopmentAuto-check passed
  • Official

    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.

    10k GitHub starsUsed in 9 repos~2.6k tokens
    DevelopmentAuto-check passed
  • Understand Diff Analysis

    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.

    86k GitHub starsUsed in 1 repo~1.4k tokens
    DevelopmentAuto-check passed
  • Understand Explain

    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.

    86k GitHub starsUsed in 1 repo~1.3k tokens
    DevelopmentAuto-check passed

More from techygarg/lattice

All 33 skills in this repo
  • Architecture Compass

    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…

    198 GitHub stars~4.4k tokensUpdated 2 days ago
    Auto-check passed
  • Lattice Init

    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…

    198 GitHub stars~3.3k tokensUpdated 2 days ago
    Auto-check passed
  • Skill Align

    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.

    198 GitHub stars~2k tokensUpdated 2 days ago
    Auto-check passed
  • Skill Validate

    techygarg/lattice

    Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners.

    198 GitHub stars~1.5k tokensUpdated 2 days ago
    Auto-check passed
  • Architecture Refiner

    techygarg/lattice

    Facilitate a structured conversation to define architecture principles for a repository.

    198 GitHub stars~3.7k tokensUpdated 2 days ago
    Auto-check passed
  • Clean Code Refiner

    techygarg/lattice

    Facilitate a structured conversation to define clean code principles for a repository.

    198 GitHub stars~3k tokensUpdated 2 days ago
    Auto-check passed

Works with

Categories

Questions about Refiners Update

What does Refiners Update do?

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.

When should I use Refiners Update?

Refiners Update fits situations like: the user says update refiners; refiners update; our standards changed; update our standards.

How do I install Refiners Update in Claude Code?

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.

How do I install Refiners Update in Codex?

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.

Can I use Refiners Update 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 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.

What does Refiners Update need to run?

Going by SKILL.md and its folder, Refiners Update needs the command-line tools its instructions call (git).

Does Refiners Update access the network?

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.

Is Refiners Update 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. Review the folder before installing.

What licence does Refiners Update use?

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.

How many tokens does Refiners Update use?

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.

What are the alternatives to Refiners Update?

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.

Who maintains Refiners Update?

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.