Coding standards, frameworks, refactoring, and code review (16.7K skills)
Get guidance on DataChain SDK APIs, method signatures, UDFs, and Python code patterns when no particular dataset or bucket is involved. It provides the rules needed to write pipeline code, including saving and exporting data.
Clean up code after tests pass by simplifying logic, removing dead code, and improving names while preserving behavior. Use it as the refactoring step in a test-driven workflow to make code easier to read and maintain without adding features.
Use the `openenv` command-line tool to scaffold a new OpenEnv environment, validate a project, build it, and push it. The skill gives the basic commands and points to help for options specific to each command.
Turn a GitHub issue into a focused development workflow: extract its goal and acceptance criteria, create an isolated worktree, enable TDD checks, and begin writing tests for the first requirement.
Monitor a pull request's CI checks and Greptile code review. The skill waits for results, helps address failures and actionable comments within set iteration limits, and reports whether the PR is ready for human review or still needs attention.
Coordinate work on several GitHub issues in parallel, creating a separate worktree and enabling test-driven development for each. A lead agent tracks conflicts and orders the completed changes into stacked pull requests, with a setup-only fallback when Agent Teams are unavailable.
Assess whether a proposed change needs an RFC, a document for discussing design decisions. Review changed files, public API changes, new patterns, and related RFCs, then report a verdict with reasoning and suggested topics to document.
Check whether changes are ready for a pull request by reviewing branch freshness, lint, tests, debug code, project principles, RFC needs, and documentation. The result is a report of blockers, reviewer discussion points, and an overall readiness verdict.
Turn a concrete use case into a new OpenEnv environment. The workflow researches the target library or API, selects relevant examples, settles key design choices, and builds typed models, client and server code, and the environment manifest.
Review code changes for mechanical defects and alignment with OpenEnv principles and RFCs. It runs lint and debug checks, then reports immediate fixes separately from design concerns that need reviewer discussion, including conflicts with open RFCs.
After `/write-tests` creates failing tests, inspect them to understand the requirements and add only the code needed to pass. Run tests as changes are made, and stop when the suite passes without adding unrelated features or refactoring.
Use this skill to turn a TLA+ system model or an agreed Mermaid chart into a state diagram people can review. It labels states and transitions in reader-friendly terms, shows rule-breaking paths, and supports checking modeled bugs against code or refining a design before implementation.
Coordinate a product change across the places that describe or consume the same fact, including code, documentation, and user-facing copy. Identify every affected surface, reduce duplicated information, and add checks or paired changes where systems share a format.
Verify how an external library, API, build backend, or scraped page behaves before relying on it. Use quick probes against the exact call or service, inspect real requests and responses, validate fakes, and check that dry-run modes do not skip the failing step.
Resolve common conflicts when several branches change the same repository. The skill explains when to combine entries, recalculate shared values, or rebuild generated files, and how to check the merged result before pushing.
Use this skill to find secrets and development clutter in Git tracking, prevent them from being committed, and clean up files already present. It explains how ignore rules differ from untracking, when credentials need rotation, and how verification can create new artifacts.
Plan Python library releases with semantic versioning and a structured changelog. The skill covers release automation with GitHub Actions, deprecation warnings, and steps for communicating breaking changes and checking a published release.
Review ffmpeg-skill changes by tracing result claims to what the tools actually measured, checking contract and documentation coverage, tests, dependencies, and project boundaries. Findings include the affected file, concrete failure, and smallest useful fix.
Build and test Python MCP servers with FastMCP, which exposes tools to LLM clients. Design predictable errors, safely wrap command-line tools, keep blocking work from stalling requests, and avoid packaging and testing pitfalls.
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.
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.
Guide planned rewrites and migrations toward a defined target architecture. Set explicit phase boundaries, allow scoped and reversible breakage where planned, and verify the result at each boundary and when the work is complete.
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.
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.