Claude Skills by tinh2

Audit and configure enterprise-managed MCP authorization (EMA) for organizations using Okta and Claude Team/Enterprise. Inventories current connector state, generates Okta provisioning configuration, validates scope assignments by IdP group, and produces a per-connector access report. Works across Claude Chat, Claude Code, and Cowork.

Migrates an MCP server from the original session-oriented protocol to the 2026 stateless spec (finalising July 28, 2026). Upgrades tool schemas to JSON Schema 2020-12, adds cloud-native routing headers, hardens OAuth 2.0/OIDC wiring, and wires W3C Trace Context for observability. Works on TypeScript and Python MCP SDK projects.

Wires Cohere's North Mini Code 1.0 (30B MoE, Apache 2.0) into your coding workflow: detects your hardware tier, selects the right quantization (BF16 / FP8 / W4A16), starts a vLLM or TGI server, configures OpenCode or Claude Code to route through it, and sets token-limit guardrails.

Sets up and optimises an OpenCode terminal-agent project: installs the CLI, configures multi-provider routing (Claude for hard tasks, Qwen/open-weight for fast tasks, Ollama for offline/air-gap), wires LSP servers for your stack, and enforces a spending-cap policy.

Safely connect X (formerly Twitter) data to Claude Code, Codex, Cursor, or Windsurf through MCP. Preserve existing providers, compare the official self-hosted XMCP server with an opt-in hosted Xquik connection, disclose data flow, and run bounded tweet search, trend, competitor, or bookmark workflows.

Guide to capturing, refining, and publishing workflows using Codex Record & Replay (launched June 18 2026). Analyzes which workflows are worth recording, walks through the capture session, refines the generated SKILL.md for publication quality, and exports it to Claude Code, Cursor, or the skills-hub registry.

Installs behavioral guardrails against classic LLM coding failures and audits the current session against them. Triggers: you hear: install guardrails, coding guardrails, stop hallucinating APIs, the agent keeps rewriting everything.

Token-efficient codebase navigation. Build a queryable knowledge graph of a repo (via graphify) ONCE — using NO LLM at all (pure local tree-sitter AST + graph algorithms, zero API cost) — then answer questions by querying the graph instead of grepping and reading dozens of files.

Semi-annual decay audit of AI scaffolding -- skills, CLAUDE.md, hooks, and memory -- deleting instructions written for older, weaker models while keeping incident post-mortems and environment facts. Triggers: 'audit my skills', 'skill decay', 'clean up CLAUDE.md'.

Project-aware skill discovery and installation. Scans the current repo for stack signals and pain points, searches the skills-hub registry and local ~/.claude/skills, scores candidates on relevance, quality, and maintenance, dedupes against what is already installed.

Curated skill bundle installer keyed to project archetype. Classifies the repo as one of six archetypes (Next.js SaaS, Flutter app, API backend, CLI tool, data pipeline, mobile game), maps it to a 5-8 skill stack covering the whole lifecycle (build, test, review, deploy, docs).

Audits your codebase for Claude Agent SDK usage affected by Anthropic's June 15 2026 billing split.

Audits a repository for all Cascade (legacy Windsurf local agent) references and migrates them to Devin Local.

Audits all connected MCP servers: auth type (OAuth vs static token), token expiry, available tools, and connection health. Flags servers that can migrate to claude mcp login OAuth flow and detects silent auth failures before they break agentic runs.

Scans your codebase for hardcoded AI model references, identifies context-window assumption violations, assesses fallback coverage, and generates a compliance-risk report with a one-file model rotation config. Run after any model suspension event or before adopting a new frontier model.

Sets up and orchestrates multi-agent workflows via the Agent Client Protocol (ACP) inside Devin Desktop or any ACP-compatible editor. Configures Claude Code, Codex, Devin Local, and custom agents with shared Spaces context, then validates the setup with an end-to-end smoke test.

Audits your AI coding tool costs across GitHub Copilot, Claude Code, Cursor, Windsurf, and other subscriptions. Analyzes usage patterns, calculates real monthly costs under token-based billing, flags budget risk, and generates a concrete optimization plan — including when switching tools makes financial sense.

Configures Claude Code's July 2026 async workflow: background agents that auto-commit, push, and open draft PRs when worktree tasks finish.

Autonomous Claude Code hooks configurator. Audits your project's existing .claude/settings.json hook setup, then installs a production-grade suite: PreToolUse safety enforcement (blocks rm -rf, sudo writes, secret leaks), PostToolUse auto-formatting and lint gates.

Auto-select the optimal Claude model tier (Haiku 4.5, Sonnet 4.6, or Opus 4.8) for each task based on complexity signals, latency requirements, and budget constraints — minimizes cost without sacrificing output quality.

Sets up and orchestrates Cursor 3 cloud agent workflows using /in-cloud for isolated VM subagents, /babysit for overnight PR preparation, Bugbot for automated pre-merge review, and reusable environment snapshots. Use after upgrading to Cursor 3.7+ or when agentic work needs to persist past your local machine.

Audits your Cursor Teams usage data and produces a right-sized Standard vs Premium seat assignment plan, saving typical teams 20–40% vs blanket Premium upgrades.

Auto-detects the current project's technology stack and hot-loads context-appropriate skills at session start using Claude Code's SessionStart hook with reloadSkills: true.

Configures Claude Code's fallbackModel chain, --safe-mode troubleshooting protocol, and /cd workspace hygiene for production-resilient autonomous coding sessions. Audits current settings, installs the optimal three-model fallback chain, and documents a fast debugging loop. Requires Claude Code v2.1.166+.

Migrates your agentic coding pipeline to GPT-5.5 — audits the current model config, switches the API endpoint, validates tool-call compatibility (including parallel-call race conditions), runs Terminal-Bench-style smoke tests, and rewrites system prompts for GPT-5.5's agentic strengths. Safe to run on existing projects.

Autonomously selects the right GPT-5.6 tier (Sol / Terra / Luna) for each coding task based on scope, file count, and planning complexity — then applies explicit cache breakpoints for SKILL.md files and system prompts. Reduces monthly AI coding costs by 50–80% without sacrificing output quality on complex tasks.

Fast single-pass spec-and-execute loop that mirrors Kiro 0.12's Quick Plan Mode. Triggers: you want spec-driven rigor without the three-gate approval workflow — spikes, small features.

Convert a plan, PRD, spec, or roadmap document into tracked GitHub issues with a dependency graph: parses the plan into atomic work items (each independently shippable, one day or less, with acceptance criteria), detects dependency cycles before creating anything.

Compress the current working session into a handoff document that a fresh session (or another person) can resume from without re-discovery. Triggers: you say \"hand off this session\", \"write a handoff\", \"save context before I close this\".

Persist, summarize, and reload agent context between sessions — writes a structured session log to CLAUDE.md / AGENTS.md / .hermes.md, snapshots decisions before destructive ops, and resumes long-running goals without re-briefing. Works with any coding agent.

Audits your active Claude Code sessions and CLAUDE.md projects, then recommends the optimal reasoning effort level (low/medium/high) for each workflow type. Configures claude-sonnet-5 as the pinned model with per-workflow effort settings, explains the token cost trade-offs, and validates the change is working as expected.

Install a token-efficiency output contract for the current session and project: writes strict brevity rules into CLAUDE.md (answer-first structure, no tool-call narration, no restated questions, no preamble filler, code without prose bookends).

Structured guide for deciding when to invoke Claude Code's ultracode mode, how to run a slice-first pilot, set token budgets, and switch effort levels per task. Prevents surprise token bills on wide codebase operations.

Verifies front-end changes by driving a real browser — spins up the local dev server, navigates to the changed route, executes the affected interaction flow, captures console output and screenshots, then reports pass/fail with structured findings.

Turn a pile of bugs, issues, and error reports into a ranked, actionable plan with reproduction evidence. Triggers: you say \"triage these bugs\", \"prioritize the backlog\", \"which bugs should we fix first\".

Hypothesis-driven debugging that ends at a proven root cause, not a symptom patch. Triggers: you say \"debug this\", \"find the root cause\", \"why is this failing\", \"this bug keeps coming back\", \"the fix didn't stick\".

Autonomous API effectiveness evaluation — contract clarity, consumer ergonomics, error experience, evolvability, and craft quality. Triggers: \"critique my API\", \"is my API well designed\", \"review API developer experience\", \"score my API\".

Assess a codebase's architecture with hard evidence — module map, dependency direction, layering breaks, coupling and cohesion hotspots weighted by git churn — then rank 3-5 improvement moves by risk-adjusted value and actually execute the lowest-risk move end to end with tests green.

Raise a site's perceived production value with a rigorous UI/UX pass while PROVING no user-facing word changed. Triggers: the user says \"make it look expensive\", \"premium design pass\", \"make it feel designed\", \"rigorous design audit\".

Audit React and Next.js codebases against roughly 50 concrete performance rules spanning re-render hygiene, bundle size, data-fetching waterfalls, images and fonts, list virtualization, and effect discipline.

Turn code-review findings into verified fixes, one commit per finding, test-first where a regression test is possible, with an explicit skip ledger for anything too risky to fix blind (auth, payments, migrations)..

Audits and implements authorization controls for production AI agent systems — policy definition, tool-call enforcement, immutable audit trails, least-privilege scoping, and MCP-layer governance. Use when shipping agents that touch production data or act on behalf of real users.

Audits and hardens Cursor agent run mode settings for Cursor 3.6+. Reviews the current run mode, writes project-appropriate classifier instructions (agent-policy.md), builds a terminal allowlist from the project's actual command usage.

Documentation-grounded plan interrogation. Before asking you anything, it extracts every third-party dependency your plan touches, fetches and reads their real documentation (node_modules READMEs and type definitions, official docs URLs, OpenAPI specs in the repo).

Turns a raw idea, brain dump, or conversation into a complete PRD with mandatory acceptance criteria and measurable success metrics. Triggers: you hear: write a PRD, turn this idea into a spec, product requirements, I have an app idea, formalize this feature.

Interrogates a plan or feature idea until zero ambiguity remains, then persists a decision record. Triggers: you hear: grill me on this plan, interrogate this idea, poke holes in my plan, stress-test this feature.

Deterministic browser automation for testing and scripted web flows using Playwright with accessibility-snapshot navigation. Triggers: you say \"test this flow in the browser\", \"automate the signup flow\", \"click through the app\", \"drive the browser\".

Enforce strict red-green-refactor test-driven development for a feature. Triggers: you want to \"do TDD\", \"build this feature test-first\", \"enforce red-green-refactor\", \"write the test first\".

Take an untested or under-tested repository to a real, running test suite in one pass. Triggers: you say \"this repo has no tests\", \"bootstrap a test suite\", \"add tests to this project\", \"set up testing from scratch\".

Extracts a complete design system from a screenshot, live URL, or existing app codebase — palette, type scale, spacing, radii, shadows, component inventory — normalized into deduplicated tokens and emitted in the target stack's format (CSS custom properties, Tailwind, Flutter ThemeData).