Smt E2E Dataflow Debugging
GoogleCloudPlatform/DataflowTemplates
Debugs logical errors and data discrepancies in Dataflow templates by launching jobs via Terraform and comparing source (e.g.
Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to…
Install Skill Enhance
$ npx skills add techygarg/lattice --skill skill-enhance -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install techygarg/lattice skill-enhance --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/dev-skills/skill-enhance .claude/skills/skill-enhance && 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 "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .claude/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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/dev-skills/skill-enhanceType 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 skill-enhance -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install techygarg/lattice skill-enhance --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/dev-skills/skill-enhance .agents/skills/skill-enhance && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .agents/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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 skill-enhance -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install techygarg/lattice skill-enhance --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/dev-skills/skill-enhance .cursor/skills/skill-enhance && 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 "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .cursor/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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 dev-skills/skill-enhance--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 skill-enhance -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install techygarg/lattice skill-enhance --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/dev-skills/skill-enhance .gemini/skills/skill-enhance && 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 "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .gemini/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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 skill-enhanceInstalls 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 skill-enhance -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/dev-skills/skill-enhance .github/skills/skill-enhance && 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 "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .github/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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 skill-enhance -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 skill-enhance --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/dev-skills/skill-enhance .opencode/skills/skill-enhance && 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 "skill-enhance" agent skill from https://github.com/techygarg/lattice/tree/main/dev-skills/skill-enhance into .opencode/skills/skill-enhance/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "skill-enhance", 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.
Facts
- Skill name
skill-enhance- GitHub stars
- 198
- Token cost
- ~1.8k tokens
- SKILL.md length
- 796 words
- Files
- 1
- Skills in repo
- 33
- Repo updated
- First seen
- Licence
- MIT
At a glance
Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to…
- Works in 6 steps: Scope and baseline → Dependency map (background agent) → Rewrite (main thread, after map returns) → …
- The user says enhance this skill
- SKILL.md covers Step 1: Scope and baseline, Step 2: Dependency map…, Step 3: Rewrite (main thread,… and Step 4: Combined QA gate…, plus 2 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Skill Enhance is an agent skill from techygarg/lattice. Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to one-unambiguous-action precision, verifies zero behavioral loss against a pre-capture diff, then runs the combined QA gate (skill-review, skill-tighten, skill-validate) and an independent fresh-context verifier, fixing everything found. Consumer-first: optimized for first-time open-source users on fresh repos with minimal…
Its SKILL.md is about 1.8k 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, covering End-to-end testing. 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 enhance this skill
- Upgrade this molecule
- Modernize this skill
- Optimize this skill
Example prompts
- “enhance this skill”
- “upgrade this molecule”
- “modernize this skill”
- “/skill-enhance”
Workflow steps
6 steps, taken from the step headings in SKILL.md.
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
No scripts in the folder and no shell commands in SKILL.md (its code samples are bash).
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
Skill Enhance loads about 1.8k tokens when it runs. Until then it costs about 237 tokens; SKILL.md has 796 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.
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). 796 words, ~1,782 tokens.
Download SKILL.mdSave it as
.claude/skills/skill-enhance/SKILL.md (or your agent's skills folder).- name
- skill-enhance
- description
- Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to one-unambiguous-action precision, verifies zero behavioral loss against a pre-capture diff, then runs the combined QA gate (skill-review, skill-tighten, skill-validate) and an independent fresh-context verifier, fixing everything found. Consumer-first: optimized for first-time open-source users on fresh repos with minimal .lattice/ setup, running capable models. Use when the user says 'enhance this skill', 'upgrade this molecule', 'modernize this skill', 'optimize this skill', 'make this skill production grade', 'full enhancement', 'polish this molecule like design-blueprint', or names a molecule/atom to overhaul. For gap-finding only use skill-review; for conventions only use skill-validate — this skill runs the whole loop end to end.
Skill Enhance
Core responsibility: Take one existing Lattice skill from current state to modern-capable-model grade through a fixed pipeline: baseline → dependency map (background agent) → precision rewrite with guaranteed behavior preservation → combined three-skill QA → independent verification. The skill being enhanced must end up smaller-or-equal in redundancy, fully grammatical, convention-complete, and provably non-regressive. Organizing objective: deterministic execution — every sentence has exactly one reading, every reachable state exactly one action, every cross-file reference literally true. Acceptance test: two different capable models reading any sentence would act identically on it.
Input: One skill path or name (any tier). Molecules are the primary case.
Output: Edited files + close-out report.
STOP: NEVER commit, push, stash, checkout, reset, or run build-codex-plugin.sh. Working tree only — surface install/mirror commands for the user instead.
How to verify this skill did its job:
- Pre-capture git diff exists; every preserved behavior in it is confirmed present after rewrite
- QA trio re-run returns no critical gaps, CLEAN or tightened-only results, and PASS
- Independent verifier reports zero real defects
- Scenario walk leaves no branch with two possible readings
Step 1: Scope and baseline
- Read PROJECT.md (single source of truth for conventions) and the target SKILL.md in full.
- Classify: tier (atom / molecule / refiner); if molecule, its type per PROJECT.md — generative (
code-forge,refactor-safely,bug-fix) or planning/interactive (design-blueprint,architecture-compass). This governs every later rule: never transplant confirmation gates into generative molecules, never strip them from planning ones. - STOP: capture the full git diff of target + likely-touched files BEFORE any edit, written to a temp file whose path you will hand to the Step 5 verifier. This baseline is the preservation oracle for Steps 3-5. Without it, "did we drop anything?" is unanswerable.
Step 2: Dependency map (background agent)
Spawn ONE background Explore agent — do not read serially in the main thread. It maps:
- Every
framework:{atom}reference: real behavior/mode names each atom actually exposes, plus line counts. - Sibling molecules feeding and consuming this one: exact handoff contracts — frontmatter fields, status values,
.lattice/{subfolder}paths, section names each side greps for. - Where the target's phases/levels are actually defined (own body vs referenced atom).
- Inventory of telegraphic damage: sentences missing articles/verbs ("ground decisions real project").
Show full SKILL.md (435 more words)Show less
Step 3: Rewrite (main thread, after map returns)
Apply in order:
- Grammar restoration — every sentence complete. Telegraphic phrasing is ambiguity risk precisely at STOP/gate semantics.
- Deduplicate — same rule twice in different words → keep the sharpest once. Cut trailing rationale ("this ensures…", "without this…") EXCEPT consequences load-bearing at the exact action point — flag every deliberate keep in the report.
- Precision pass — hard gates get
**STOP:**prefixes; targeted questions replace generic approval language; every conditional branch (missing doc, unreadable path, external reference, absent config, outputs created by older skill versions missing newer fields) resolves to exactly ONE action; expected-not-error paths marked as such. - Scenario walk your own rewrite: fresh start / interrupted session / partial output / minimal input / maximal input / entry-and-resume edges (including partial entry points and legacy docs without new markers). Derive the state space from upstream contracts first — enumerate every status value, mode name, and doc-presence combination the upstream defines, and give each a defined outcome here. Close every gap where two readings survive.
- Preservation check against the Step 1 baseline — nothing dropped, renamed, or weakened.
- Contract alignment — verify every referenced behavior name, section heading, table schema, config key, and status value against the live atom files; fix mismatches even when pre-existing. Composition must interlock literally, not approximately.
- Convention restoration — always/conditional qualifiers on Required Skills, collaborative-judgment fallback wording in Ambiguity Signals, trigger phrases in description, description consistent with body.
- If the skill repurposes a code-generation atom in another mode: give that atom a compact named mode section. Never improvise inline; never inline atom content into a molecule.
Step 4: Combined QA gate (strict order)
Run on every touched file:
- skill-review — fix criticals and warnings; list observations for the user decision.
- skill-tighten — full T1-T6 sweep, apply.
- skill-validate — fix error-level findings directly; report warnings without applying.
Iterate until all three return clean/pass. Re-run any skill whose inputs a later fix changed.
Step 5: Independent verification (background agent)
Spawn ONE fresh general-purpose verifier that re-derives correctness WITHOUT trusting the diff author:
- Semantic-preservation checklist from the Step 1 baseline
- Internal-consistency scenario walk (Step 3.4 scenarios, independently)
- Contract checks against the real consumer files — grep them, cite lines
- Hedge/degraded-grammar grep across touched files
- Frontmatter YAML validity, name/folder match
Fix everything it finds. Then: behavior-affecting fixes → re-run the affected Step 4 tools; single-line narrowing fixes → self-check against the loaded T1-T6/validator patterns instead of a full re-run.
Step 6: Close-out report
Report: files changed with before→after line counts; findings per QA tool and how each closed; deliberate keeps flagged; residual validator warnings listed untouched; and these commands surfaced for the user (not run):
./tools/install.sh <your-tool>/skills/ # smoke-test the skill loads
./tools/build-codex-plugin.sh # refresh Codex mirror before committing© 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 dev-skills/skill-enhance of techygarg/lattice.
Open the folder on GitHubat commit 4d6c35f
Compare with similar skills
Skill Enhance 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 |
|---|---|---|---|---|---|---|
| Skill Enhance this skilltechygarg/lattice | 198 | — | ~1.8k | Automated safety check: Pass | MIT | |
| Smt E2E Dataflow DebuggingGoogleCloudPlatform/DataflowTemplates | 1.3k | — | ~1.8k | Automated safety check: Pass | Apache-2.0 | |
| Debugging MarchatCod-e-Codes/marchat | 137 | — | ~668 | Automated safety check: Notes | MIT | |
| Alefxberg-io/alef | 100 | — | ~1.7k | Automated safety check: Pass | MIT | |
| Jinja Codegenxberg-io/alef | 100 | — | ~735 | Automated safety check: Pass | MIT | |
| Feature Development WorkflowQwenLM/qwen-code | 28k | — | ~1.2k | Automated safety check: Pass | Apache-2.0 |
Similar skills
Debugging Marchat
Cod-e-Codes/marchat
Diagnoses marchat client and server issues using -doctor, env configuration, and logs.
Alef
xberg-io/alef
Use Alef correctly for Rust-to-polyglot binding generation. An agent skill from xberg-io/alef.
Jinja Codegen
xberg-io/alef
Mechanics of alef's Minijinja template system: which templateenv module to call, how to register a template, inline-template rules, and engine settings.
Feature Development Workflow
QwenLM/qwen-code
Phased workflow for non-trivial qwen-code features: investigate, design doc, E2E test plan, baseline dry-run, implement, verify, self-audit, review and iterate.
- Official
Unblock Dependabot PR
kubernetes-sigs/cloud-provider-azure
Diagnose and unblock failed Dependabot pull requests in cloud-provider-azure by closing Kubernetes minor-version dependency bumps, classifying CI failures, syncing Go modules, retesting quota-flaked…
More from techygarg/lattice
All 33 skills in this repoArchitecture 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…
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…
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.
Skill Validate
techygarg/lattice
Validate any Lattice SKILL.md against all tier conventions — atoms, molecules, and refiners.
Architecture Refiner
techygarg/lattice
Facilitate a structured conversation to define architecture principles for a repository.
Clean Code Refiner
techygarg/lattice
Facilitate a structured conversation to define clean code principles for a repository.
Related
Categories
Questions about Skill Enhance
What does Skill Enhance do?
Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to…. Skill Enhance is an agent skill from techygarg/lattice. Full enhancement pipeline for an existing Lattice skill — rewrites a molecule or atom to modern-capable-model grade: restores degraded grammar, deduplicates, hardens gates and branching to one-unambiguous-action precision, verifies zero behavioral loss against a pre-capture diff, then runs the combined QA gate (skill-review, skill-tighten, skill-validate) and an independent fresh-context verifier, fixing everything found.
When should I use Skill Enhance?
Skill Enhance fits situations like: the user says enhance this skill; upgrade this molecule; modernize this skill; optimize this skill.
How do I install Skill Enhance in Claude Code?
Run `npx skills add techygarg/lattice --skill skill-enhance -a claude-code`. Or copy the skill folder (dev-skills/skill-enhance in techygarg/lattice) into .claude/skills/skill-enhance in your project. Claude Code loads it when a task matches its description.
How do I install Skill Enhance in Codex?
Run `npx skills add techygarg/lattice --skill skill-enhance -a codex`. Or copy the skill folder (dev-skills/skill-enhance in techygarg/lattice) into .agents/skills/skill-enhance in your project. Codex loads it when a task matches its description.
Can I use Skill Enhance 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 skill-enhance -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/skill-enhance, .gemini/skills/skill-enhance, .github/skills/skill-enhance and .opencode/skills/skill-enhance in your project.
What does Skill Enhance need to run?
SKILL.md names no scripts, command-line tools or credentials: Skill Enhance is instructions for the agent only.
Does Skill Enhance 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 Skill Enhance 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 Skill Enhance use?
Skill Enhance 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 Skill Enhance use?
About 1.8k tokens (SKILL.md is roughly 7.1k 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 Skill Enhance?
Skills that share tags, products or a category with Skill Enhance: Smt E2E Dataflow Debugging (GoogleCloudPlatform/DataflowTemplates, 1.3k stars), Debugging Marchat (Cod-e-Codes/marchat, 137 stars), Alef (xberg-io/alef, 100 stars) and Jinja Codegen (xberg-io/alef, 100 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Skill Enhance?
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.