10x-swe

Plugin 10x-swe from marketplace terminal-agent-plugins in cercova-studios/terminal-agent-plugins. Commands read from the repo's manifest — 28 days ago.

Skills (69)

• agent-browser

  Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form

• architecture-decision-records

  Write and maintain Architecture Decision Records (ADRs) following best practices for technical decision documentation. Use when documenting significant technical decisions, reviewing past architectural choices, or establishing decision processes.

• ast-grep

  Guide for writing ast-grep rules to perform structural code search and analysis. Use when users need to search codebases using Abstract Syntax Tree (AST) patterns, find specific code structures, or perform complex code queries that go beyond simple text search. This skill should be used when users a

• async-python-patterns

  Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.

• bash-defensive-patterns

  Master defensive Bash programming techniques for production-grade scripts. Use when writing robust shell scripts, CI/CD pipelines, or system utilities requiring fault tolerance and safety.

• binary-analysis-patterns

  Master binary analysis patterns including disassembly, decompilation, control flow analysis, and code pattern recognition. Use when analyzing executables, understanding compiled code, or performing static analysis on binaries.

• brainstorming

  You MUST use this before any creative work - creating features, building components, adding functionality, or modifying behavior. Explores user intent, requirements and design before implementation.

• browser-use

  Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, or extract information from web pages.

• chrome-devtools

  Browser automation, debugging, and performance analysis using Puppeteer CLI scripts. Use for automating browsers, taking screenshots, analyzing performance, monitoring network traffic, web scraping, form automation, and JavaScript debugging.

• cli-developer

  Use when building CLI tools, implementing argument parsing, or adding interactive prompts. Invoke for CLI design, argument parsing, interactive prompts, progress indicators, shell completions.

• code-research

  Investigate architecture, library APIs, engineering tradeoffs or unfamiliar behavior using inspected source and current primary evidence.

• code-search

  Routes local code lookup by intent: literal identifiers, syntax, repository layout, or meaning. Use before broad code research.

• cqrs-implementation

  Implement Command Query Responsibility Segregation for scalable architectures. Use when separating read and write models, optimizing query performance, or building event-sourced systems.

• create-agent-skills

  Author, audit and improve portable skills with bounded capabilities, clear triggers, progressive disclosure, provenance and meaningful verification.

• deep-architecture-analysis

  Performs comprehensive reverse engineering and architecture analysis of GitHub repositories and application binaries. Identifies inefficiencies, bloat, vulnerabilities, and architectural patterns. Deconstructs from first principles to recommend optimal tech stacks for rewrites and modernization.

• diagnose

  Diagnose reproducible bugs and performance regressions with a bounded feedback loop, falsifiable hypotheses, targeted probes and regression evidence.

• dispatching-parallel-agents

  Coordinate authorized independent tasks with bounded ownership, explicit handoffs and integrated verification.

• doppler-secrets

  Use the Doppler CLI to access and manage secrets safely in both ad hoc scripts and long-lived projects. Covers CLI install, env injection, project binding via doppler.yaml, environments, service tokens, Docker, Kubernetes, and CI/CD integration. Use when a task touches secrets and must avoid exposin

• e2e-testing-patterns

  Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs, improve confidence, and enable fast deployment. Use when implementing E2E tests, debugging flaky tests, or establishing testing standards.

• error-handling-patterns

  Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

• find-skills

  Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable ski

• finishing-a-development-branch

  Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

• frontend-design

  Create distinctive, production-grade frontend interfaces with high design quality. Use this skill when the user asks to build web components, pages, or applications. Generates creative, polished code that avoids generic AI aesthetics.

• gemini

  Gemini CLI for one-shot Q&A, summaries, and generation.

• gh-cli

  GitHub CLI (gh) comprehensive reference for repositories, issues, pull requests, Actions, projects, releases, gists, codespaces, organizations, extensions, and all GitHub operations from the command line.

• ghidra

  Reverse engineer binaries using Ghidra's headless analyzer. Decompile executables, extract functions, strings, symbols, and analyze call graphs without GUI.

• go-concurrency-patterns

  Master Go concurrency with goroutines, channels, sync primitives, and context. Use when building concurrent Go applications, implementing worker pools, or debugging race conditions.

• golang-backend-development

  Complete guide for Go backend development including concurrency patterns, web servers, database integration, microservices, and production deployment

• grill-me

  Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

• grill-with-docs

  Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.

• improve-codebase-architecture

  Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

• jujutsu-vcs

  Guide AI agents to use Jujutsu (jj) for version control. Covers core concepts, daily workflows, Git compatibility, conflict resolution, and collaboration with GitHub. Use this skill when working with jj repositories or when the user wants to use Jujutsu instead of Git.

• langchain-architecture

  Design LLM applications using LangChain 1.x and LangGraph for agents, memory, and tool integration. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.

• langgraph-docs

  Use this skill for requests related to LangGraph in order to fetch relevant documentation to provide accurate, up-to-date guidance.

• llm-evaluation

  Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance, measuring AI application quality, or establishing evaluation frameworks.

• memory-safety-patterns

  Implement memory-safe programming with RAII, ownership, smart pointers, and resource management across Rust, C++, and C. Use when writing safe systems code, managing resources, or preventing memory bugs.

• microservices-patterns

  Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.

• obsidian-cli

  Interact with Obsidian vaults using the Obsidian CLI to read, create, search, and manage notes, tasks, properties, and more. Also supports plugin and theme development with commands to reload plugins, run JavaScript, capture errors, take screenshots, and inspect the DOM. Use when the user asks to in

• obsidian-markdown

  Create and edit Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties, and other Obsidian-specific syntax. Use when working with .md files in Obsidian, or when the user mentions wikilinks, callouts, frontmatter, tags, embeds, or Obsidian notes.

• openai-docs

  Use when the user asks how to build with OpenAI products or APIs and needs up-to-date official documentation with citations (for example: Codex, Responses API, Chat Completions, Apps SDK, Agents SDK, Realtime, model capabilities or limits); prioritize OpenAI docs MCP tools and restrict any fallback

• osgrep-semantic-search

  Semantic code search via the `osgrep` CLI. Use when the user wants to find code by behavior, concept, or intent ("where do we validate JWTs?", "where is rate limiting handled?") rather than by exact text. Prefer ripgrep for literal matches and ast-grep for structural patterns.

• parallel-debugging

  Compare independent hypotheses when a reproduced failure spans multiple causes; use parallel investigators only with explicit authorization.

• playwright-cli

  Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

• postgresql-table-design

  Design a PostgreSQL-specific schema. Covers best-practices, data types, indexing, constraints, performance patterns, and advanced features

• prompt-engineering-patterns

  Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, improving LLM outputs, or designing production prompt templates.

• python-anti-patterns

  Common Python anti-patterns to avoid. Use as a checklist when reviewing code, before finalizing implementations, or when debugging issues that might stem from known bad practices.

• python-background-jobs

  Python background job patterns including task queues, workers, and event-driven architecture. Use when implementing async task processing, job queues, long-running operations, or decoupling work from request/response cycles.

• python-code-style

  Python code style, linting, formatting, naming conventions, and documentation standards. Use when writing new code, reviewing style, configuring linters, writing docstrings, or establishing project standards.

• python-configuration

  Python configuration management via environment variables and typed settings. Use when externalizing config, setting up pydantic-settings, managing secrets, or implementing environment-specific behavior.

• python-design-patterns

  Python design patterns including KISS, Separation of Concerns, Single Responsibility, and composition over inheritance. Use when making architecture decisions, refactoring code structure, or evaluating when abstractions are appropriate.

• python-error-handling

  Python error handling patterns including input validation, exception hierarchies, and partial failure handling. Use when implementing validation logic, designing exception strategies, handling batch processing failures, or building robust APIs.

• python-observability

  Python observability patterns including structured logging, metrics, and distributed tracing. Use when adding logging, implementing metrics collection, setting up tracing, or debugging production systems.

• python-performance-optimization

  Profile and optimize Python code using cProfile, memory profilers, and performance best practices. Use when debugging slow Python code, optimizing bottlenecks, or improving application performance.

• python-resilience

  Python resilience patterns including automatic retries, exponential backoff, timeouts, and fault-tolerant decorators. Use when adding retry logic, implementing timeouts, building fault-tolerant services, or handling transient failures.

• python-resource-management

  Python resource management with context managers, cleanup patterns, and streaming. Use when managing connections, file handles, implementing cleanup logic, or building streaming responses with accumulated state.

• python-testing-patterns

  Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.

• python-type-safety

  Python type safety with type hints, generics, protocols, and strict type checking. Use when adding type annotations, implementing generic classes, defining structural interfaces, or configuring mypy/pyright.

• refactor

  Improve code structure while preserving observable behavior, data contracts and error handling through small verified changes.

• research-readwise-obsidian

  Use the Readwise CLI to run relevance-first research across Reader documents and highlights, then synthesize an Obsidian-ready note with source-linked evidence and explicit confidence gaps. Use when researching topics from Readwise content for PKM workflows in Obsidian.

• self-learning

  Autonomous skill generator that learns new technologies from the web. Use when, users want to learn about a new library/framework/tool, need to create a skill for an unfamiliar technology, want to research and document a technology's usage patterns, or invoke with `/learn <topic>`. This skill uses w

• spring-boot-engineer

  Use when building Spring Boot 3.x applications, microservices, or reactive Java applications. Invoke for Spring Data JPA, Spring Security 6, WebFlux, Spring Cloud integration.

• sql-optimization-patterns

  Master SQL query optimization, indexing strategies, and EXPLAIN analysis to dramatically improve database performance and eliminate slow queries. Use when debugging slow queries, designing database schemas, or optimizing application performance.

• subagent-driven-development

  Use when executing implementation plans with independent tasks in the current session

• task-coordination-strategies

  Decompose complex tasks, design dependency graphs, and coordinate multi-agent work with proper task descriptions and workload balancing. Use this skill when breaking down work for agent teams, managing task dependencies, or monitoring team progress.

• test-driven-development

  Use when implementing any feature or bugfix, before writing implementation code

• tmux

  Remote control tmux sessions for interactive CLIs (python, gdb, etc.) by sending keystrokes and scraping pane output.

• using-git-worktrees
• uv-package-manager
• x-api

Slash commands (5)

• /10x-swe:create-agent-skill

  Create or edit agent skills with expert guidance on structure and best practices

• /10x-swe:create-prompt

  Create a new prompt that another Claude can execute

• /10x-swe:research-readwise-obsidian

  Research topics with Readwise CLI and produce Obsidian-ready notes

• /10x-swe:research

  Conduct in-depth code research using tiered tool strategy

• /10x-swe:run_prompt

  Delegate one or more prompts to fresh sub-task contexts with parallel or sequential execution

Subagents (9)

• code-improvement-scanner

  Use this agent when you need to review code for potential improvements in readability, performance, or adherence to best practices. This includes after completing a feature implementation, during code review preparation, when refactoring legacy code, or when you want a second opinion on code quality

• code-reviewer

  Use this agent when you need to review code for adherence to project guidelines, style guides, and best practices. This agent should be used proactively after writing or modifying code, especially before committing changes or creating pull requests. It will check for style violations, potential issu

• code-simplifier

  Simplifies and refines code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code unless instructed otherwise.

• code-simplifier

  Use this agent when code has been written or modified and needs to be simplified for clarity, consistency, and maintainability while preserving all functionality. This agent should be triggered automatically after completing a coding task or writing a logical chunk of code. It simplifies code by fol

• comment-analyzer

  Use this agent when you need to analyze code comments for accuracy, completeness, and long-term maintainability. This includes: (1) After generating large documentation comments or docstrings, (2) Before finalizing a pull request that adds or modifies comments, (3) When reviewing existing comments f

• pr-test-analyzer

  Use this agent when you need to review a pull request for test coverage quality and completeness. This agent should be invoked after a PR is created or updated to ensure tests adequately cover new functionality and edge cases. Examples:\n\n<example>\nContext: Daisy has just created a pull request wi

• ruthless-code-reviewer

  Use this agent when you want a brutally honest, no-holds-barred code review that will expose every flaw, questionable decision, and architectural weakness in recently written code. This agent should be invoked after completing a feature, function, or logical chunk of code that needs rigorous scrutin

• silent-failure-hunter

  Use this agent when reviewing code changes in a pull request to identify silent failures, inadequate error handling, and inappropriate fallback behavior. This agent should be invoked proactively after completing a logical chunk of work that involves error handling, catch blocks, fallback logic, or a

• type-design-analyzer

  Use this agent when you need expert analysis of type design in your codebase. Specifically use it: (1) when introducing a new type to ensure it follows best practices for encapsulation and invariant expression, (2) during pull request creation to review all types being added, (3) when refactoring ex

Similar plugins