pattern-critic_skill

Overview

This skill is a critic agent that reviews pattern TypeScript code for violations of documented rules, gotchas, and anti-patterns. It produces a categorized checklist with [PASS]/[FAIL] for each rule and includes line-numbered fixes for any failures. The output is designed to be actionable and easy to scan by developers and reviewers.

How this skill works

Read the target pattern file, inspect each of the defined violation categories (module scope, reactivity, binding, style, etc.), and generate a checklist report in the standardized format. For every failed rule include the line number and a concise fix; for passes and non-applicable items mark them accordingly. Summarize counts and list priority fixes at the end.

When to use it

• Before merging a pattern change to catch gotchas and regressions.
• During code review to enforce architecture and reactivity rules.
• When onboarding engineers to surface common pattern pitfalls.
• When integrating LLM features to validate schema and directives.
• For periodic design reviews to validate domain model quality.

Best practices

• Keep handlers and helper functions at module scope; use action() inside patterns when appropriate.
• Wrap any derived values in computed() instead of closing over reactive values directly.
• Use $-prefixed bindings ($value, $checked) for two-way binding; bind properties not whole objects.
• Prefer object style for HTML elements and string style for ct-* custom elements.
• Avoid creating handlers inside .map(); create once and bind per-item to reduce allocations.

Example use cases

• Automated pre-merge checks that produce a quick list of PASS/FAIL items for reviewers.
• CI integration that fails the build when critical reactivity or binding violations are detected.
• Refactor pass to identify module-scope violations and move helpers out of pattern body.
• LLM-driven feature validation to ensure correct generateObject schema and directives.
• Performance audits to find per-item handler creation and expensive inline computations.