개발 스킬

Apply consistent TypeScript practices when reading or editing .ts and .tsx files. Model valid states with precise types, validate external data at boundaries, handle every variant, and prefer real tests and structured diagnostics where practical.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Reviewing TypeScript code
• Editing .ts or .tsx files
• Validating data from external sources

Use this skill when concurrent work may write to the same file, branch, key, or state object. It helps identify shared mutable state, split independent outputs, and serialize writes only when a single shared target is truly required.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Planning parallel work that may touch shared files
• Separating worker outputs before integration
• Choosing when a shared write needs a lock or sequential phase

Organize validation and error handling at system boundaries such as command inputs, configuration, networks, and external APIs. Keep internal business logic focused on typed data and pure functions, making it easier to test without framework wiring.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Deciding where input validation belongs
• Separating business logic from framework code
• Reviewing how external data becomes typed state

Audit a project’s verification skill by checking each feature against source code and exercising it in a live session. The result is an honest feature map and, when proven corrections are needed, one focused pull request.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Reviewing whether a feature map still matches the application
• Checking documented features through live use
• Correcting verification instructions with evidence

Use this skill to address mistakes agents repeatedly make in a repository. It groups recurring errors and guides fixes through architecture, types, lint checks, and tests, with evidence that each check catches a real past mistake; documentation is reserved for judgment calls.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Preventing repeated agent mistakes in a codebase
• Turning past errors into enforced checks
• Reviewing repository rules and their enforcement

Use this skill to review comments in specified files or a code diff. It delegates a fresh review, evaluates findings, fixes accepted issues, and proposes ways to encode claimed constraints in types, runtime checks, tests, or CI lint.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Reviewing comments in a code diff
• Removing comments that describe changeable code
• Finding ways to enforce a claimed constraint with tests or lint

Sequence additions, refactors, and rewrites by simplifying the existing system first. Remove dead code, redundant checks, and empty stubs, then build on the smaller base while avoiding speculative safeguards and prompt clutter.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Simplify a codebase before adding a feature
• Remove redundant checks during a refactor
• Trim prompts or delete empty reference stubs

Shape code around the real concepts and rules of a domain. Use state machines, typed models, registries, reducers, or other fitting structures to reduce scattered branches, repeated assumptions, and invalid states while avoiding abstractions that add needless indirection.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Replace growing conditional chains with a domain model
• Represent lifecycle states clearly
• Remove repeated data shape assumptions across files

Assess what a code change could break beyond the visible diff. Trace less obvious effects, identify the key assumption that makes the change safe, and test that assumption by running real code before presenting risks and cleared concerns.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Assessing the blast radius of a proposed code change
• Reviewing a small diff whose safety is uncertain
• Checking downstream effects beyond direct callers

Use this principle when replacing an internal API and coordinating changes across its callers. It recommends moving callers to the new contract and removing the old API in the same change, with tests focused on the new behavior rather than refactoring details.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Replacing an internal API
• Coordinating a breaking refactor
• Updating tests for a new API contract

Use this skill when designing types or reviewing function signatures in statically typed code. It helps distinguish values that share a primitive representation, parse untrusted input at system boundaries, handle every variant, and derive types from the schema that defines the data.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Distinguishing IDs or values that share the same primitive type
• Parsing JSON, configuration, or database input into typed models
• Checking that every variant is handled

Design commands and processing steps that can safely run again after retries or crashes. The skill guides agents to compare current state with the goal, apply only needed changes, and make leftover files or records recognizable as stale.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Making a command safe to run repeatedly
• Handling a process that may stop halfway
• Reviewing cleanup of stale files or records

Use this skill when multiple fixes based on the same assumption fail the same check. It guides the agent to write down and test that assumption, then use the evidence to decide whether to investigate another cause or address the root cause.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Investigating repeated failures at the same check
• Testing an assumption shared by earlier fixes
• Choosing the next step from failure patterns

Explore a codebase and explain how a feature or subsystem works, how runtime steps connect, and where code belongs. It creates a concise architectural walkthrough for onboarding or before making changes, using subagents for larger questions.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Understand how a feature or subsystem works
• Trace runtime flow before changing code
• Find the right package or architectural layer for new code

Use this skill during refactoring or diff review to favor deletion and the smallest change that solves the problem. It encourages one source of truth for repeated decisions and helps avoid unnecessary abstractions, layers, and boilerplate.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Reducing an oversized code diff
• Reviewing whether a new abstraction is needed
• Consolidating repeated decisions into one source of truth

For nontrivial edits, migrations, analyses, or checks, build a small repeatable tool such as a script, codemod, or generator. The tool becomes a reviewable artifact others can rerun to verify the work consistently.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Automate a repetitive code change
• Create a script to verify a migration
• Generate recurring files consistently

Guide early implementation decisions by shaping core data structures and types, ordering setup before feature work, and isolating shared state when concurrent actors can modify it. The aim is to make later logic clearer and keep each change coherent.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Choosing core types and data structures before coding
• Sequencing shared setup ahead of feature work
• Considering risks when concurrent actors share state

Build a local page with buttons or a dashboard that sends JSON to a webhook and wakes a Grok Bot. Keep the sender key on the server, request it through a secret prompt, and expose the page to Tailscale peers when needed.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Building a button-based bot control page
• Sending form data to a Grok Bot webhook
• Keeping a webhook key out of browser code

Integrate a new requirement by reconsidering the existing design as if the requirement had been there from the start. The skill guides updates across affected types, documentation, examples, and rationale, delivered incrementally.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Adding a requirement to an existing design
• Reworking related types and documentation together
• Planning a redesign before implementing it incrementally

Generate several parallel candidates for the same task, compare them against concrete criteria, and choose a base to improve with selected strengths from the other candidates. The skill then verifies the synthesized result and records how it was assembled.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Comparing several designs for one task
• Exploring options before making a substantial change
• Combining the strongest parts of parallel drafts

Use this skill to shape non-trivial code before implementation. It grounds the design in the surrounding system, compares structurally distinct options, and creates a type and module sketch that guides coding. If implementation repeatedly conflicts with the sketch, it revisits the architecture.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Planning module boundaries before a feature implementation
• Comparing design options for a non-trivial change
• Revisiting a sketch when implementation needs repeated workarounds

Designs a reviewable workflow for complex work that does not fit an existing playbook, such as a large migration or multi-part change. It breaks work into testable steps, scales checks to risk, and records decisions so a reviewer can understand the result later.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Plan a large migration with reviewable steps
• Break a multi-part change into experiments
• Create an auditable workflow for work done over time

Use this skill to make hard-to-trace code easier to understand. It examines indirection and hidden mutable state, then suggests collapsing unnecessary wrappers and narrowing state scope so readers can find where values come from and what can change them.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Reviewing a code path with too many layers
• Simplifying wrappers with only one caller
• Reducing shared mutable state in a module

Break migrations, broad edits, and other multi-step work into small changes, checking each one before moving on. Arrange commits and pull requests so reviewers can follow the evidence and verify how the work progresses.

한국어 요약은 준비 중입니다. 영어 요약을 표시하고 있습니다.

• Making a large set of similar edits
• Running a migration in checkable steps
• Stacking commits to show the reasoning