Coding standards, frameworks, refactoring, and code review (15K skills)
Turn a course plan into numbered exercise folders with problem, solution, and explanation variants. Create starter readme files, check naming and links with the project’s linter, and fix structural errors before committing.
Set up dependency-cruiser in a TypeScript project to enforce package boundaries, keep internal files private, and detect circular dependencies. Includes an example package, verification of the rules, and documentation for future development.
Clarify a project's business concepts and terminology through concrete scenarios and comparisons with code. Record agreed definitions in a glossary and document significant design trade-offs in ADRs, records explaining why a decision was made.
Prepare a repository for engineering skills by documenting where issues are tracked, which triage labels organize incoming work, and where glossaries and architecture decision records belong. Review the existing setup and confirm drafts before writing configuration files.
Turn a specification and its tickets into code by coordinating multiple agents around task dependencies. Combine their work on one integration branch, use test-driven development, review the result, and close tickets through the issue tracker’s workflow.
Sharpen a plan or design through persistent questioning while creating documentation along the way. The resulting documents include architecture decision records, which capture design choices, and a glossary of terms used in the discussion.
Implement work described in a specification or tickets, checking types and running tests along the way. Review the completed changes with the code-review skill, then commit the implementation to the current branch.
Write a pull request description that helps reviewers understand a code change. Use a compact diagram or diff, show before-and-after evidence, and explain how reversible the change is and what areas it may affect.
Review code changes from a chosen Git reference against two separate criteria: documented coding standards and the original requirements. Independent reviewers check each criterion, then present findings separately so convention problems and requirement gaps remain visible.
Investigate difficult bugs and performance slowdowns by building a repeatable test or script that detects the exact symptom. Reduce the failing case, compare possible causes, and verify the fix with checks that catch the bug if it returns.
Turn an existing discussion and codebase knowledge into a specification, then publish it to the project's issue tracker. Organize the problem, user needs, implementation decisions, testing approach, and work excluded from scope.
Check skills before distributing them to Codex or Cursor. Identify unsupported metadata fields, Claude-specific variables in shell examples, and inconsistencies between source skills and their installation copies using the project's compatibility checker.
Set up Everything Claude Code skills and hooks in DeepSeek Harness. Covers linking skill folders, generating hook settings, checking that hooks run, updating the setup, and investigating missing skills or inactive hooks.
Audit a focused part of an existing codebase, reconstruct its behavior and past decisions, and record gaps in reasoning, coding practices, features, and technology choices. Use the findings to plan, test, implement, and verify improvements.
Map the impact of a proposed change using real dependencies and project documentation. Identify affected code, data, interfaces, tests, and release steps, then compare the implemented changes with the plan to expose gaps and unverified risks.
Design and review Java database code using MyBatis and MyBatis-Spring. Covers mapping query results to objects, safe SQL parameters, transactions, pagination, batch writes, and investigating slow or unnecessarily repeated queries.
Turn Git changes into a clear commit message using Conventional Commits, a format that labels the change type and optional scope. Review repository history to match its conventions, and flag unrelated changes that should be split.
Structure server-side applications with practical patterns for Node.js, Express, and Next.js API routes. Covers API design, database queries, caching, authentication, error handling, and background jobs, with examples that separate business rules from data access.
Apply shared coding conventions to new modules, reviews, and refactoring. Guides descriptive naming, readable structure, updates that preserve existing data, and error handling, giving teams a consistent basis for checking code quality.
Turn Claude Code sessions into reusable working rules with evidence and confidence scores. Keep project-specific habits separate, share general patterns across projects, and group learned rules into skills, commands, or agents for repeated tasks.
Design and review REST APIs, interfaces that exchange resources over HTTP, with consistent URLs, responses, and error handling. Covers pagination, authentication, request limits, and versioning to clarify how clients interact with an API.
Plan database structure changes and existing data updates for production systems. Provides migration patterns for adding columns and indexes, switching applications in stages, and documenting recovery steps while accounting for downtime and database locks.
Design local data storage in Swift using actors, which control concurrent access to shared data. Combine an in-memory cache with JSON file storage, implement save and lookup operations, and connect the repository to an observable ViewModel.
Build Java applications with tinystruct, including actions usable from both a terminal and the web. Get guidance on launcher generation, routing, JSON responses, database storage, tests, and MCP tools that agents can call.