jhlee0409

Code and component analysis — analyze code, trace flows, audit consistency, inspect components

Architecture analysis and design review

Full auto pipeline — run spec-to-clean cycle automatically for new features

Save session state for later resumption

Resolve spec ambiguities with clarifying questions

Pipeline artifact cleanup and codebase hygiene

Expert consultation — backend, infra, PM, design, marketing, legal, or tech guidance

Bug diagnosis and fix — root-cause analysis for errors, crashes, broken behavior

Read-only maintainability audit of a whole codebase — ranks the files most likely to cause maintenance pain (size × churn hotspots, test gaps, lint debt) and proposes discrete fixes, each as its own PR. Use before a cleanup/refactor pass, when inheriting a codebase, or when the user says "유지보수성 점검", "어디부터 리팩토링", "코드베이스 상태 봐줘", "where is the tech debt?", "what should we clean up first?". Produces a findings table + top-3 fix proposals; it edits nothing and stores no grade.

Scan a repository's tech stack and generate a tailored Claude Code harness for it — a thin .claude/CLAUDE.md spine, stack-specific architect agent(s), and specs/ADR scaffolding — fitting the generic harness-kit engine to this repo. Use when setting up the harness in a new or existing repo, or when the user says "set up the harness here", "introspect this repo", "tailor claude config", "scaffold .claude for this project".

Enumerate the full impact set of a symbol before or during a change — every reference, caller, implementation/subtype, and reverse import — plus an explicit list of what could NOT be resolved (dynamic dispatch, reflection, generated code). Use before touching a shared / exported / widely-imported symbol, before an interface or signature change, or when the user asks "what breaks if I change this?", "어디까지 영향 가?", "누락 없이 찾아줘", "전부 찾았어?". Produces an evidence table + an "enumeration complete?" checklist; read-only.

Resolve a change request into an EXACT edit target before touching code, then gate the edit on tests — the localize → edit → validate loop. Use for a bug fix, an issue, or a feature change where the right files/symbols are not already obvious, or when the user says "이거 고쳐줘", "어디를 고쳐야 해?", "fix this issue", "where does this live?". Produces a localization artifact (targets + evidence + uncertainty) first; edits only after it, validates with a focused test then a regression run.

Record an architecture / cross-cutting decision as the next numbered ADR under docs/adr/. Use when a non-obvious or hard-to-reverse decision is made (a module boundary, a trade-off, a tech choice), or when the user says "record an ADR", "ADR 남겨", "이 결정 기록", "document this decision".

Scaffold a spec triplet (spec.md / plan.md / context.md) under specs/YYYYMMDD-<name>/ before starting a non-trivial piece of work. Use when a task spans multiple modules / several commits / a new ADR, or when the user says "new spec", "스펙 만들어", "plan this out", "spec this", "기획부터".

Re-enter in-flight work in a fresh session by reading a resume block a previous session left (the read half of the handoff/pickup loop). Use at the start of a fresh session, or when the user says "pickup", "resume", "이어서", "재개", "어디까지 했지", "continue where we left off".

Create an isolated git worktree for a code-change task (../<repo>-<slug> on its own branch), keeping the main checkout clean. Use in a repo that opted into the worktree-per-task workflow, or when the user says "new worktree", "워크트리 만들어", "isolate this task", "task별 worktree".

Creates custom React hooks for SideDish. Use when the user asks to create a new hook, extract shared logic into a hook, or refactor component logic into reusable hooks. Includes TypeScript interfaces, memoization patterns, and index.ts export.

API 아키텍처 설계 원칙과 패턴을 적용합니다. RESTful API 설계, 버저닝, 응답 표준화, 미들웨어 패턴 구현 시 사용하세요. Next.js App Router 기반 서버리스 아키텍처에 최적화되어 있습니다.

Creates Next.js API routes with Firebase. Use when adding GET/POST/PATCH/DELETE endpoints, implementing pagination, adding auth checks, or handling file uploads. Includes route templates and error handling.

Creates React components for SideDish. Use when adding new UI components, modals, forms, or interactive elements. Includes TypeScript interfaces, styling patterns, and security considerations.

Firestore 데이터 모델링과 스키마 설계 패턴을 적용합니다. 새 컬렉션 추가, 관계 설계, 인덱스 최적화, 데이터 마이그레이션 시 사용하세요. NoSQL 특성에 맞는 비정규화 전략을 포함합니다.

Debugs common issues in SideDish. Use when fixing errors, investigating bugs, troubleshooting API failures, or resolving build issues. Includes common error patterns, logging strategies, and debugging tools.

일관된 에러 처리와 로깅 패턴을 구현합니다. API 에러 응답, 예외 처리, 에러 바운더리, 사용자 친화적 메시지 작성 시 사용하세요. 서버와 클라이언트 양쪽의 에러 처리 전략을 포함합니다.

Performs Firebase Firestore operations. Use when querying collections, creating/updating/deleting documents, using batch writes, or working with Timestamps. Includes pagination, transactions, and security rules patterns.

Check and install OpenAPI Sync MCP server dependency

Best practice templates for API layer scaffolding

Detect and analyze FSD layer structure in a project

Generate FSD-compliant slice boilerplate with pattern matching

Check FSD import boundary rules and detect violations

Manage analysis cache for incremental FSD validation

Manage OpenAPI spec cache and implementation state for efficient diff-based sync

Universal code generator - clones your existing code style exactly

The knowledge layer for the learning loop. Explains how to read and act on the work-pattern snapshot that glm-learning-loop injects at SessionStart — what the verification ratio means, what tool over-reliance signals, how to adapt behavior based on past-session telemetry. ROUTE BY INTENT — load when the model receives a work-pattern snapshot and needs to interpret it, when the user asks "how do I work?" / "내 작업 패턴 뭐야" / "am I verifying enough?", or when adapting this session based on past behavior. Also load when the user wants to inspect or clear the telemetry that drives the loop. NOT a stats viewer (that's /session-stats) — this is the interpretive layer that turns numbers into behavioral change.

Detect the current repo's tech stack from its manifest files and recommend which ZCode skills, MCP servers, and plugins fit. Reads package.json (Node: React/Next.js/Vue/Svelte/Express/Nest), pyproject.toml + requirements.txt (Python: FastAPI/Django/Flask), go.mod (Go: echo/gin/fiber), Cargo.toml (Rust: axum/actix/tokio), pom.xml + build.gradle (Java: Spring/Maven/Gradle), composer.json (PHP: Laravel/Symfony), Gemfile (Ruby: Rails/Sinatra). ROUTE BY INTENT, NOT KEYWORDS — load when the user starts a new project ("이 레포 스택 뭐야", "what stack is this", "어떤 기술 쓰지", "set up for this repo"), asks for tooling recommendations, or when a fresh session needs to orient on an unfamiliar repo. Also load proactively at session start on an unfamiliar repo — orienting on the stack is step zero. Returns a stack fingerprint (language + framework + package manager + test runner + notable deps) + a recommendation table (skill/MCP/plugin → why it fits → install hint). Does NOT auto-enable anything — it recommends, the user decides.

JUDGE whether an already-rendered UI surface is good enough to ship — quality evaluation of something that EXISTS, not creation of something new. GLM-5.2 has no vision, so judgment runs on Playwright-MCP computed-style probes (getComputedStyle JSON: fontSize / color / padding / gap / contrast), not on eyeballing pixels. Scores 7 dimensions PASS/FAIL (visual hierarchy / spacing-rhythm / alignment / contrast+WCAG / density / design-token conformance / DESIGN.md-tone) + runs a 13-tell "AI-slop" gate (warm-cream hero, near-black+neon, Inter-only, white+purple, uniform sizing, vague headlines, scattered motion…). ROUTE BY INTENT, NOT KEYWORDS — load this whenever the intent is to evaluate quality of a built surface, including indirect signals: a shared screenshot the user reacts to with dissatisfaction, hesitation, or silence; "이거 이상하지 않아?", "괜찮아?", "어때"; a ship/no-ship decision moment ("출시해도 돼?", "이대로 갈까?"); any qualitative complaint about a rendered screen ("AI스러워", "올드해", "트렌디하지 않아", "이탈하고 싶어져"); explicit revie

CONVERGE an EXISTING rendered UI surface to good craft through a closed measured loop — judge → fix-list → edit code → HMR re-render → re-judge → repeat until PROCEED or a 3-round cap. Probe-driven (Playwright-MCP computed-style JSON), not eyeballing, because GLM-5.2 has no vision. Inlines the 7-dim rubric + 13-tell slop gate so a surface can be converged in-loop. ROUTE BY INTENT, NOT KEYWORDS — load this whenever the intent is to REPEATEDLY IMPROVE a built surface until it is good, including indirect signals: "이거 계속 비슷해" (a prior one-shot fix did not land), "쓰레기 UI 고쳐", "UI 다듬어", "개선 루프 돌려", "craft 올려", "make this converge", any vibe that one-shot review is not enough and the user wants to iterate to satisfaction. NOT for designing a new screen from JTBD (that is ux-design-baseline). NOT for a single quality verdict (that is design-craft-rubric — judge once). NOT for runtime mechanics.

PRODUCE the design intent for a UI feature that does not yet exist — the design thinking BEFORE code. Frames the job-to-be-done (what user behavior change, measured how), grounds in the repo's DESIGN.md + FLOWMAP, audits the current-state surfaces with a severity-scored findings table + cognitive walkthrough, DECIDES craft forks with conviction (north-star default shown — never dumps an a/b menu on the user), and produces a durable design.md (9-section template, slim/full tier). Repo-agnostic: each repo's DESIGN.md owns tone, each repo's FLOWMAP owns the flow map. ROUTE BY INTENT, NOT KEYWORDS — load this whenever the intent is to FIGURE OUT the design for something to be built, including indirect signals: a feature request that needs design thinking before code ("이 기능 만들어줘", "이 화면 추가하자"), a "how should this work?" question about user flow, a request for a wireframe or design doc, any moment where the user wants to decide what to build before building it. NOT for judging an already-rendered surface (that is d

Enforce the "no premature done" discipline. Before claiming a task is complete, the model MUST produce real evidence — a test run with passing output, a real DB query result, a rendered screenshot, a build that compiles, a command's actual stdout. "200 OK" alone, fake fixtures (fake JWT, synthetic audio), or code-inference without execution are NOT evidence. ROUTE BY INTENT, NOT KEYWORDS — load this whenever the model is about to say "done", "complete", "fixed", "finished", "완료", "구현 완료", or any completion claim, OR when the user asks "did it work?", "are you sure?", "진짜야?", or expresses doubt about a claim. Also load when a conclusion lacks a quantitative basis (test count, response time, measured value). Returns either evidence (command + output / test result) or an explicit "확인 불가" (cannot verify) verdict with the missing evidence named. NOT a code editor — it produces or demands evidence, never edits code.

Architecture Decision Record template + when to write one. An ADR is a short markdown record of a significant architectural decision, its context, and its consequences — durable history that answers "why is it like this?" months later. ROUTE BY INTENT — load when making a non-obvious architectural decision ("이걸 왜 이렇게 했지?" later, "should we use X or Y for..."), when a decision is hard to reverse, or when you need to look up why a past choice was made. NOT for implementation details (that's code comments) or ephemeral task notes (that's a spec).

How to author a ZCode SKILL.md that triggers reliably and stays lean. The format, the description discipline (route-by-intent, not keywords), progressive disclosure (metadata → body → bundled files), and the anti-over-build stance (delete guidance that isn't pulling its weight). ROUTE BY INTENT — load when writing a new skill, revising an existing one, turning a repeated workflow into a skill, or debugging why a skill doesn't trigger. NOT for authoring plugins/hooks (those are separate).

Manage centralized domain constants and configuration in the project. Use when adding new status types, modifying UI labels, updating color schemes, or creating configuration objects for domain entities.

Parse Figma design files into structured screen hierarchies. Use when working with Figma API, extracting text/labels from design nodes, traversing node trees, detecting cover frames, or parsing screen IDs (AUTO_0001, PSET_0002, etc.).

Integrate Google Gemini API for AI-powered QA checklist generation and structured output. Use when working with Gemini API calls, generating QA checklists from design specs, parsing AI responses, or implementing structured output with JSON schema.

Implement localStorage persistence in Next.js 14 App Router with SSR-safe patterns. Use when storing data in localStorage, handling hydration errors, implementing state persistence, or creating type-safe storage utilities.

Build React Portal-based dropdown, modal, and overlay components. Use when creating dropdown menus, select components, modals, tooltips, or any UI that needs to escape overflow containers. Includes positioning, scroll handling, keyboard navigation, and accessibility patterns.

Manage QA test case workflows, status transitions, and verification checklists. Use when working with QA status states (Reviewing, DevError, ProdError, DevDone, ProdDone, Hold, Rejected, Duplicate), progress tracking (Waiting, Checking, Working, DevDeployed, ProdDeployed), activity logging, or test case management.

Implement WBS (Work Breakdown Structure) and Gantt chart functionality. Use when working with task scheduling, date range calculations, drag-and-drop timeline interactions, or project planning features.

Debug canvas layout issues, grid positioning problems, and component overlap. Use when troubleshooting Konva canvas rendering, grid constraints, snap-to-grid behavior, or visual layout mismatches. Includes Canvas→CSS Grid conversion debugging.

Review code for Visual Layout Builder quality standards including TypeScript patterns, React 2025 best practices, accessibility, and performance. Use when reviewing PRs, checking code quality, or ensuring compliance with project conventions.

Write comprehensive unit tests for Visual Layout Builder using Vitest. Use when creating tests for lib/ functions, schema validation, canvas utilities, or any business logic. Follows AAA pattern and project testing conventions.

Develop and optimize AI prompt strategies for code generation. Use when creating new AI model strategies, optimizing prompts for Claude/GPT/Gemini/DeepSeek/Grok, or improving prompt quality. Includes model-specific optimization techniques.

Create and modify Visual Layout Builder schema components, breakpoints, and layouts. Use when working with types/schema.ts, creating new components, adding breakpoints, or modifying layout configurations. Helps ensure Component Independence architecture compliance.

Run a structured production-readiness analysis on the codebase

This skill should be used when the user asks to "commit", "push", "ship", "create PR", "merge", or when user indicates they want to save/publish changes. Verifies all quality gates pass before allowing git operations.