SystangoTechnologies
25 verified skills
code-simplification
Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.
development
jira-planning-and-task-breakdown
Breaks Jira story work into ordered tasks. Use when you have a story spec and need to break work into implementable tasks with story-scoped files under `jira-spec/{story-id}/`. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.
tools
jira-shipping-and-launch
Prepares production launches and updates Jira ticket/task comments. Use when preparing to deploy to production and when launch readiness/progress must be communicated in Jira.
devops
jira-spec-driven-development
Creates specs before coding with mandatory Jira MCP validation and story-key grounding. Use when starting a Jira-tracked feature or significant change and requirements are unclear, ambiguous, or incomplete.
tools
shipping-and-launch
Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.
testing
api-and-interface-design
Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.
development
skills/brownfield-discovery
--- name: brownfield-discovery description: Maps an existing codebase systematically. Use when entering an unfamiliar project, before writing specs or plans, or when you need to understand tech stack, architecture, conventions, business context, and outstanding concerns. Use when NOT: starting a greenfield project — you already understand the architecture. --- # Brownfield Discovery ## Overview When you land in an unfamiliar codebase, you need to understand *what this thing does*, *how it's b
development
code-review-and-quality
Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.
development
context-engineering
Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.
testing
debugging-and-error-recovery
Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.
development
deprecation-and-migration
Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.
development
generate-unit-tests
Generates unit tests for already-implemented features by reading deferred test notes from the task list and analyzing source code. Use after the build phase when tasks in specs/tasks/todo.md have an unchecked "Tests written" checkbox. Use when running /test to execute the test phase.
development
git-workflow-and-versioning
Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.
development
idea-refine
Refines ideas iteratively. Refine ideas through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger.
tools
incremental-implementation
Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.
development
planning-and-task-breakdown
Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.
tools
quick-task-execution
Executes a small, ad-hoc change with one short plan and one atomic commit — skipping the full spec → plan → build ceremony. Use when the change is narrow, single-domain, and the approach is obvious. Use when `/spec` → `/plan` → `/build` would cost more than the work itself. Do NOT use for multi-file features, new public interfaces, or work with real ambiguity.
development
spec-driven-development
Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.
development
using-agent-skills
Discovers and invokes agent skills. Use when starting a session or when you need to discover which skill applies to the current task. This is the meta-skill that governs how all other skills are discovered and invoked.
development
browser-testing-with-devtools
Tests in real browsers. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data via Chrome DevTools MCP.
tools
performance-optimization
Optimizes application performance. Use when performance requirements exist, when you suspect performance regressions, or when Core Web Vitals or load times need improvement. Use when profiling reveals bottlenecks that need fixing.
development
security-and-hardening
Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.
development
documentation-and-adrs
Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.
development
source-driven-development
Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.
development
frontend-ui-engineering
Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.
development