Dynamo Webview Component Scaffold
DynamoDS/Dynamo
Scaffolds a new Dynamo package repo that hosts a view extension with a WebView2-embedded React frontend.
A skill your agent uses to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against…
Install Adversarial TS Patterns
$ npx skills add pproenca/dot-skills --skill adversarial-ts-patterns -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install pproenca/dot-skills adversarial-ts-patterns --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/pproenca/dot-skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .claude/skills/adversarial-ts-patterns && 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 "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .claude/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patternsType 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 pproenca/dot-skills --skill adversarial-ts-patterns -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install pproenca/dot-skills adversarial-ts-patterns --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/pproenca/dot-skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .agents/skills/adversarial-ts-patterns && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .agents/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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 pproenca/dot-skills --skill adversarial-ts-patterns -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install pproenca/dot-skills adversarial-ts-patterns --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/pproenca/dot-skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .cursor/skills/adversarial-ts-patterns && 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 "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .cursor/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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/pproenca/dot-skills.git --path skills/.experimental/adversarial-ts-patterns--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 pproenca/dot-skills --skill adversarial-ts-patterns -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install pproenca/dot-skills adversarial-ts-patterns --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/pproenca/dot-skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .gemini/skills/adversarial-ts-patterns && 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 "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .gemini/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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 pproenca/dot-skills adversarial-ts-patternsInstalls 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 pproenca/dot-skills --skill adversarial-ts-patterns -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/pproenca/dot-skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .github/skills/adversarial-ts-patterns && 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 "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .github/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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 pproenca/dot-skills --skill adversarial-ts-patterns -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install pproenca/dot-skills adversarial-ts-patterns --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/pproenca/dot-skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/.experimental/adversarial-ts-patterns .opencode/skills/adversarial-ts-patterns && 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 "adversarial-ts-patterns" agent skill from https://github.com/pproenca/dot-skills/tree/master/skills/.experimental/adversarial-ts-patterns into .opencode/skills/adversarial-ts-patterns/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "adversarial-ts-patterns", 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
adversarial-ts-patterns- GitHub stars
- 214
- Token cost
- ~1.8k tokens
- SKILL.md length
- 829 words
- Files
- 24 (incl. references, assets)
- Skills in repo
- 182
- Repo updated
- First seen
- Licence
- MIT
At a glance
A skill your agent uses to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against…
- Works in 6 steps: Identify the target. Pin down exactly… → Load the rules. Read… → Compose the reviewer prompt. Fill… → …
- File set against 18 decidable rules covering implicit state machines (boolean-flag lifecycles
- SKILL.md covers When to Apply, Review Protocol, Verdict Format and Rule Categories, plus 2 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Adversarial TS Patterns is an agent skill from pproenca/dot-skills. Use this skill to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against 18 decidable rules covering implicit state machines (boolean-flag lifecycles, useEffect chains, stored derived state, non-exhaustive union matches) and over-engineered OO/enterprise ports (getInstance singletons, factory and builder classes, single-method strategy classes, State/Visitor hierarchies, event buses inside a React…
Its SKILL.md is about 1.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 26 other files, including reference files and assets (for example `assets/templates/verdict.md`, `gotchas.md` and `metadata.json`).
It sits in Development, covering Design patterns and Subagents. It works with React, TypeScript, C# and Java. The repository describes itself as: A collection of AI agent skills following the Agent Skills open format. The licence is MIT.
When your agent uses it
- File set against 18 decidable rules covering implicit state machines (boolean-flag lifecycles
- UseEffect chains
- Stored derived state
- Non-exhaustive union matches) and over-engineered OO/enterprise ports (getInstance singletons
Example prompts
- “/adversarial-ts-patterns”
Workflow steps
6 steps, taken from the first numbered list in SKILL.md.
- Identify the target. Pin down exactly what is under review (a diff, a set of files, a PR) and note the ref/paths so the review runs…
- Load the rules. Read references/_sections.md and every rule file in references/ (all state-*.md, create-*.md, behave-*.md, layer-*.md…
- Compose the reviewer prompt. Fill references/reviewer-prompt.md with the rules and the target. The composed prompt must be fully…
- Dispatch one blind reviewer. Launch a single Task subagent whose entire input is the composed prompt — no conversation context, no…
- Render fail-closed. The reviewer's structured output is the verdict — there is no merge step. Overall verdict is PASS only when every rule…
- Render the verdict. Fill assets/templates/verdict.md. On FAIL, aggregate the reviewer's "missing for PASS" suggestions into the fix list…
What it can do on your machine
Read from SKILL.md and the folder at commit cf93c57. 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.
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
Adversarial TS Patterns loads about 1.8k tokens when it runs, and up to ~13k if it reads all its reference files. Until then it costs about 248 tokens; SKILL.md has 829 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 pproenca/dot-skills at commit cf93c57, republished under its MIT licence (© pproenca). 829 words, ~1,843 tokens.
Download SKILL.mdSave it as
.claude/skills/adversarial-ts-patterns/SKILL.md (or your agent's skills folder). This skill also uses 23 other files; get the full folder from GitHub.- name
- adversarial-ts-patterns
- description
- Use this skill to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against 18 decidable rules covering implicit state machines (boolean-flag lifecycles, useEffect chains, stored derived state, non-exhaustive union matches) and over-engineered OO/enterprise ports (getInstance singletons, factory and builder classes, single-method strategy classes, State/Visitor hierarchies, event buses inside a React tree, pass-through repositories, DI containers, single-implementation interfaces, component inheritance, logic-only HOCs, static-only classes, trivial accessors). Trigger it before merging TS/React work, when asked to gate or pass/fail pattern usage, or as a check that agent-authored code is not porting Java/C# idioms. It renders verdicts only; for teaching-style guidance use implementation-design-patterns or implementation-functional-patterns.
Adversarial TS Patterns Gate
A design-pattern usage gate for TypeScript and React application code — a pass/fail gate: a single blind reviewer subagent judges the work against this gate's rules with an adversarial mandate, and the work passes only when every rule is PASS or N/A. This skill renders verdicts; it never fixes the work.
The gate judges in both directions. Over-abstraction — Gang of Four and enterprise machinery ported from Java/C# where idiomatic TypeScript reaches for a function, a module, or a tagged union. Under-modeling — implicit state machines whose impossible states compile: boolean-flag lifecycles, effect chains, hand-synced derived state, silent default branches.
When to Apply
- A TypeScript/React diff or feature is about to merge and needs an objective PASS/FAIL on pattern usage, not advisory feedback.
- An agent (Claude, Codex) authored the code and you want an independent check that it is not reproducing Java/C# training-data idioms — Singleton classes, factory hierarchies, repository wrappers, JavaBean accessors.
- A migration from another stack (Java, C#, Angular-style DI) claims completion and the ported architecture needs auditing for layers that lost their justification in TypeScript.
- Component or store state grew organically and you want the implicit-state-machine failure modes (contradictory booleans, effect chains, non-exhaustive matches) caught before they ship.
Do not apply to non-TypeScript codebases (the reviewer prompt's precondition aborts with "GATE NOT APPLICABLE"), or when the user wants explanations and refactors rather than a verdict — that is the job of the curated implementation-design-patterns and implementation-functional-patterns skills. React-specific rules go N/A in non-React TypeScript projects; the rest of the gate works in any TypeScript application.
Review Protocol
Follow these steps exactly — the gate's value is that every review runs the same way.
- Identify the target. Pin down exactly what is under review (a diff, a set of files, a PR) and note the ref/paths so the review runs against an unambiguous, fixed target. Include the repo root in the target description — the
layer-no-single-impl-interfaceandlayer-no-di-container-in-apprules require searching beyond the diff for second implementations and registrations. - Load the rules. Read references/_sections.md and every rule file in
references/(allstate-*.md,create-*.md,behave-*.md,layer-*.md,react-*.md,oo-*.mdfiles). - Compose the reviewer prompt. Fill references/reviewer-prompt.md with the rules and the target. The composed prompt must be fully self-contained — a reviewer sees no conversation history, so nothing may refer to context outside the prompt.
- Dispatch one blind reviewer. Launch a single Task subagent whose entire input is the composed prompt — no conversation context, no commentary alongside it.
- Render fail-closed. The reviewer's structured output is the verdict — there is no merge step. Overall verdict is PASS only when every rule is PASS or N/A; any single FAIL fails the gate. Never average, weigh severity, or waive a rule — a "minor" FAIL is a FAIL. If the reviewer returns "GATE NOT APPLICABLE" (not a TypeScript target), stop and report that instead of a verdict.
- Render the verdict. Fill assets/templates/verdict.md. On FAIL, aggregate the reviewer's "missing for PASS" suggestions into the fix list, each with its location, ordered by category importance. Every rule whose final result is FAIL must appear in the fix list with a change concrete enough to apply as written — if the reviewer's suggestion only restates the violation, derive the fix from the rule's Correct example before rendering.
If the same rule flips verdicts across re-reviews of an unchanged target, or a human reads the evidence and overrides the verdict, that is a decidability bug in the rule — record it in gotchas.md and sharpen the rule; do not override the gate.
Show full SKILL.md (245 more words)Show less
Verdict Format
The reviewer returns, per rule: PASS | FAIL | N/A, evidence (file:line or a quote — required for PASS as well as FAIL), and for every FAIL, the fix that flips the rule to PASS once applied — the named change plus its location, never a restatement of the violation. The final report follows assets/templates/verdict.md.
Rule Categories
| # | Category | Prefix | Covers |
|---|---|---|---|
| 1 | State Modeling & Machines | state- | Discriminated unions over boolean flags, no effect chains, no stored derived state, exhaustive matches with never |
| 2 | Creational Ports | create- | No getInstance() singletons, no factory-class hierarchies, no builders for option bags |
| 3 | Behavioral Ports | behave- | Functions over single-method classes, unions over State/Visitor hierarchies, no event buses inside a React tree |
| 4 | Enterprise Layers | layer- | No pass-through repositories, no DI containers with single implementations, no single-implementation interfaces |
| 5 | React Composition | react- | No component inheritance, hooks over logic-only HOCs, props over imperative handles |
| 6 | OO Ceremony | oo- | No static-only container classes, no trivial accessor pairs |
Related Skills
implementation-design-patterns(curated) — the teaching-style reference for when a GoF class form is warranted; use it when the goal is guidance or refactoring rather than a verdict.implementation-functional-patterns(curated) — the GoF-to-functional map this gate'screate-/behave-rules enforce the reviewable subset of.adversarial-tanstack/adversarial-zod— framework- and library-level gates for TanStack Start apps; run alongside this gate for full coverage of a Start diff.
Reference Files
| File | Description |
|---|---|
| references/reviewer-prompt.md | Self-contained prompt template for the blind reviewer |
| assets/templates/verdict.md | Verdict report template |
| references/_sections.md | Category definitions and ordering |
| metadata.json | Version and source references |
© pproenca, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 23 other files (references, assets) in skills/.experimental/adversarial-ts-patterns of pproenca/dot-skills.
- SKILL.md
- assets/templates/verdict.md
- gotchas.md
- metadata.json
- references/_sections.md
- references/behave-no-event-bus-in-tree.md
- references/behave-no-single-method-class.md
- references/behave-union-over-state-visitor-classes.md
- references/create-no-builder-for-optional-bag.md
- references/create-no-factory-class-hierarchy.md
- references/create-no-getinstance-singleton.md
- references/layer-no-di-container-in-app.md
- references/layer-no-passthrough-repository.md
- references/layer-no-single-impl-interface.md
- references/oo-no-static-only-class.md
- references/oo-no-trivial-accessors.md
- references/react-no-component-inheritance.md
- references/react-no-hoc-for-logic-reuse.md
- … and 6 more
Open the folder on GitHubat commit cf93c57
Compare with similar skills
Adversarial TS Patterns 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 |
|---|---|---|---|---|---|---|
| Adversarial TS Patterns this skillpproenca/dot-skills | 214 | — | ~1.8k | Automated safety check: Pass | MIT | |
| Dynamo Webview Component ScaffoldDynamoDS/Dynamo | 2k | — | ~991 | Automated safety check: Pass | Apache-2.0 | |
| Design Patternswaybarrios/opencode-power-pack | 533 | — | ~2.2k | Automated safety check: Pass | MIT | |
| React Render Types CompositionHorusGoul/eslint-plugin-react-render-types | 111 | — | ~1.1k | Automated safety check: Pass | MIT | |
| Developing Softwaretelagod/code-abyss | 244 | — | ~410 | Automated safety check: Pass | MIT | |
| Build Teaql Appteaql/teaql-agent-kit | 2.8k | — | ~4.6k | Automated safety check: Pass | MIT |
Similar skills
Design Patterns
waybarrios/opencode-power-pack
Agents should invoke this skill when choosing patterns, designing traits/interfaces/components, deciding abstraction boundaries, evaluating dependency injection/callbacks, or comparing…
React Render Types Composition
HorusGoul/eslint-plugin-react-render-types
Composition patterns for building React components with @renders type annotations from eslint-plugin-react-render-types.
Developing Software
telagod/code-abyss
Software development knowledge reference covering Python, Go, Rust, TypeScript, Java, C++, and Shell.
Build Teaql App
teaql/teaql-agent-kit
Build or change a TeaQL application in Java, Rust, Go, Swift, Python, C/.NET, or TypeScript, including Kotlin/JVM applications that consume Java-generated libraries.
Growing Outside In Systems
lexler/skill-factory
Drive feature development using Outside-In TDD with Hexagonal Architecture.
More from pproenca/dot-skills
All 182 skills in this repoAudio Voice Recovery
pproenca/dot-skills
Audio forensics and voice recovery guidelines for CSI-level audio analysis.
Codemod React Pipeline
pproenca/dot-skills
Guided, scripted pipeline for running JSX/TSX/React codemods safely across large legacy codebases.
Dev Rfc
pproenca/dot-skills
Create well-structured RFCs and technical proposals for software projects.
Dx Harness
pproenca/dot-skills
Developer-experience friction auditing and fixing — slow onboarding, repeated manual setup steps, missing bootstrap/reset/seed scripts, undiscoverable conventions.
Language Spec Author
pproenca/dot-skills
Turn a rough idea for a language into a complete, implementable specification — a DSL, query, config/data, template, or protocol language — by interviewing the author dimension by dimension until…
Python Pep Author
pproenca/dot-skills
Drafting Python Enhancement Proposals (PEPs) — proposing a Python language feature, a standard library change, an interoperability standard, or an informational/process document for the Python…
Related
Works with
Categories
Questions about Adversarial TS Patterns
What does Adversarial TS Patterns do?
A skill your agent uses to gate TypeScript and React application code with a pass/fail adversarial review of design-pattern usage — a single blind reviewer subagent judges a diff or file set against…. Adversarial TS Patterns is an agent skill from pproenca/dot-skills.
When should I use Adversarial TS Patterns?
Adversarial TS Patterns fits situations like: file set against 18 decidable rules covering implicit state machines (boolean-flag lifecycles; useEffect chains; stored derived state; non-exhaustive union matches) and over-engineered OO/enterprise ports (getInstance singletons.
How do I install Adversarial TS Patterns in Claude Code?
Run `npx skills add pproenca/dot-skills --skill adversarial-ts-patterns -a claude-code`. Or copy the skill folder (skills/.experimental/adversarial-ts-patterns in pproenca/dot-skills) into .claude/skills/adversarial-ts-patterns in your project. Claude Code loads it when a task matches its description.
How do I install Adversarial TS Patterns in Codex?
Run `npx skills add pproenca/dot-skills --skill adversarial-ts-patterns -a codex`. Or copy the skill folder (skills/.experimental/adversarial-ts-patterns in pproenca/dot-skills) into .agents/skills/adversarial-ts-patterns in your project. Codex loads it when a task matches its description.
Can I use Adversarial TS Patterns 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 pproenca/dot-skills --skill adversarial-ts-patterns -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/adversarial-ts-patterns, .gemini/skills/adversarial-ts-patterns, .github/skills/adversarial-ts-patterns and .opencode/skills/adversarial-ts-patterns in your project.
What does Adversarial TS Patterns need to run?
SKILL.md names no scripts, command-line tools or credentials: Adversarial TS Patterns is instructions for the agent only.
Does Adversarial TS Patterns 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 Adversarial TS Patterns 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 Adversarial TS Patterns use?
Adversarial TS Patterns 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 Adversarial TS Patterns use?
About 1.8k tokens (SKILL.md is roughly 7.4k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 11k tokens, read only when the agent opens those files.
What are the alternatives to Adversarial TS Patterns?
Skills that share tags, products or a category with Adversarial TS Patterns: Dynamo Webview Component Scaffold (DynamoDS/Dynamo, 2k stars), Design Patterns (waybarrios/opencode-power-pack, 533 stars), React Render Types Composition (HorusGoul/eslint-plugin-react-render-types, 111 stars) and Developing Software (telagod/code-abyss, 244 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Adversarial TS Patterns?
pproenca (a GitHub user) maintains it in pproenca/dot-skills, which has 214 GitHub stars. The repository holds 182 skills in this directory. The repository was last updated on August 15, 2026.
Source: pproenca/dot-skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.