lugassawan
UserClaude Code & Pi Coding Agent plugin — senior-engineer toolkit: Clean Architecture, DDD, SOLID, TDD, design patterns, security review, and language expertise across Bash, C#, Dart, Go, Java, Kotlin, Python, Ruby, Rust, SQL, Swift, and TypeScript.
Categories
Indexed Skills (50)
workflow-address-feedback
Use when a PR owner wants to address review feedback — fetches outstanding threads and general comments, presents a per-item triage (ADDRESSED / CLARIFIED / DEFERRED), applies fixes via the Edit tool, commits via workflow-commit-and-pr, resolves review threads via GraphQL resolveReviewThread (those without a thread are never resolved), and syncs stale PR metadata when drift is detected.
workflow-branch-sync
Sync the current branch with the default branch via rimba or git, then resolve conflicts file by file with a per-hunk rationale and a keep-mine / keep-main / manual recommendation before staging. Push only happens after explicit confirmation — never automatic.
workflow-bug-triage
Use when investigating a bug to root-cause and FILE a GitHub issue rather than fixing immediately — counterpart to /swe-workbench:debug (which patches). Enforces the Iron Law (no patches without root cause), and produces a structured issue with code-path table and impact assessment.
workflow-cleanup-merged
Use after a PR has been merged on GitHub to remove the local worktree, delete the local branch, delete the remote branch, and fast-forward local main — safely, with squash-merge support.
workflow-codebase-audit
Use for cold-start, time-boxed, multi-axis audits of unfamiliar codebases — take-home assessments, post-acquisition or due-diligence reviews, pre-refactor tech-debt sweeps. Dispatches the auditor subagent for the broad sweep, optionally fans out to security-auditor / debugger on top findings (only when --depth=deep), and renders ranked findings with reasoning chains and counter-evidence fields.
workflow-commit-and-pr
Use when the user wants to commit staged changes or create a PR — enforces trigger-phrase discipline (preview vs commit vs ship), the [type] commit format, branch-naming check, draft-vs-ready PR prompt, and PR template detection. Pre-merge counterpart to workflow-cleanup-merged.
workflow-audit-emit-issues
After a codebase audit, groups audit findings by subsystem (path prefix) and emits them as context-rich GitHub issues with template discovery, label selection, and a batch preview-confirm gate before filing. Keywords — audit findings grouped github issues subsystem emit.
language-bash
Bash idioms — strict mode, parameter expansion, arrays, trap cleanup, heredocs, and POSIX portability. Auto-load when working with .sh, .bash files, or when the user mentions bash, shell, shellcheck, set -e, or pipefail.
language-csharp
C# and .NET idioms — .NET 8 LTS, C# NRT, records, value semantics, switch expressions, async/await, Task, ValueTask, CancellationToken, ConfigureAwait, IOptions<T>, LINQ, Span<T>, ArrayPool, hot path, allocation profiling, and performance. Auto-load when working with .cs files, .csproj, .sln, Directory.Build.props, or when the user mentions C#, dotnet, .NET 8, C# NRT, NRT, records, value semantics, switch expressions, Task, ValueTask, CancellationToken, ConfigureAwait, LINQ, Span, or hot-path code.
language-dart
Dart idioms — null safety, Futures and Streams, widget composition, and Riverpod app architecture. Auto-load when working with .dart files, pubspec.yaml, or when the user mentions Dart, Flutter, widgets, Riverpod, Streams, or null safety.
language-go
Go idioms — error handling, concurrency, and standard library usage. Auto-load when working with .go files, go.mod, go.sum, or when the user mentions Go, Golang, goroutines, channels, context, or error wrapping.
language-java
Java idioms — records, sealed types, virtual threads, and JDK 21+ patterns. Auto-load when working with .java files, pom.xml, build.gradle, or when the user mentions Java, JVM, Spring, Maven, Gradle, sealed classes, or virtual threads.
language-kotlin
Kotlin idioms — null safety, sealed interfaces, scope functions, and Flow. Auto-load when working with .kt files, build.gradle.kts, or when the user mentions Kotlin, coroutines, StateFlow, or Kotlin DSL.
language-python
Python idioms — PEP 8, context managers, generators, asyncio, and testing. Auto-load when working with .py files, pyproject.toml, requirements.txt, or when the user mentions Python, pytest, asyncio, dataclass, type hints, or virtualenv.
language-ruby
Ruby idioms — Ruby 3.x pattern matching, procs, Comparable, error handling, and testing. Auto-load when working with .rb files, Gemfile, Rakefile, gemspecs, or when the user mentions Ruby, blocks, procs, lambdas, or pattern matching.
language-rust
Rust idioms — ownership, lifetimes, and iterators. Auto-load when working with .rs files, Cargo.toml, or when the user mentions Rust, cargo, ownership, borrow checker, lifetime, or async Rust.
language-sql
SQL idioms — query tuning, table definitions, constraints, transactions, and pagination. Auto-load when working with .sql files or migrations, or when the user mentions SELECT, JOIN, EXPLAIN, CTE, window functions, or SQL indexes.
language-swift
Swift idioms — optionals, value types, async/await, and Result builders. Auto-load when working with .swift files, Package.swift, or when the user mentions Swift, SwiftUI, actors, Result builders, or Swift Package Manager.
language-typescript
TypeScript and JavaScript idioms — strict mode, async patterns, and Node. Auto-load when working with .ts, .tsx, .js, .jsx files, package.json, or when the user mentions TypeScript, JavaScript, type safety, or tsconfig.
observability-context
Fetch production observability signals from Sentry — error, regression, and alert data. Auto-loads on Sentry references. Returns message/culprit, first-seen, always labeled as Phase-1 framing, never a profile.
principle-accessibility
Accessibility (a11y) principles — WCAG 2.2 AA conformance, semantic HTML, keyboard navigation, focus management, focus traps, color contrast, alt text, screen reader compatibility, reduced motion. Auto-load when reviewing frontend or UI code, evaluating ARIA usage, auditing color contrast, building modals or dialogs, choosing between semantic elements and ARIA workarounds, or assessing screen-reader experience.
principle-api-design
API design principles — contract-first thinking, semantic versioning, idempotency keys, pagination (offset vs cursor), REST vs RPC vs event-driven trade-offs, resource modeling, deprecation strategy. Auto-load when designing an API, adding api versioning, adding pagination, shaping error responses, or evolving a public contract.
principle-clean-architecture
Clean Architecture, hexagonal architecture, ports and adapters, and dependency rule. Auto-load when designing architecture, choosing layers, ports, adapters, or keeping the domain free of framework code.
principle-clean-code
Clean code, DRY, KISS, YAGNI, function length, abstraction level, function argument count, Boy Scout Rule, intent-revealing naming. Auto-load when writing functions, reviewing code clarity, or debating whether to abstract.
principle-code-review
Code review heuristics — five-axis review lens (correctness, security, design integrity, test coverage, comment quality); review comment tone (observation over accusation); nitpick filtering; distinguishing a real finding from linter noise. Auto-load when writing or framing a review comment, reviewing a diff for correctness, or filtering review nitpicks.
principle-communication
Caveman output mode — ultra-terse brief replies with fewer tokens. Strips filler, hedging, pleasantries. Three levels — caveman lite (default), caveman full, ultra caveman / max caveman (maximum compression). Persists until normal mode. Auto-load when the user requests terser output, says "be brief", "less tokens", "caveman mode", "use fewer tokens", or invokes `/caveman`.
principle-concurrency
Concurrency principles — race conditions, livelock, backpressure, lock-free primitives, choosing between mutex vs channel vs actor vs semaphore vs CAS. Auto-load when designing concurrent code, fixing a deadlock, choosing a synchronization primitive, or reasoning about goroutine/thread/task lifetimes.
principle-cost-awareness
Cost awareness principles — FinOps mindset, right-sizing, cost-per-request model, storage tier selection, cardinality explosion, log volume. Auto-load when reasoning about cloud costs, right-sizing instances, scale-to-zero trade-offs, or FinOps budget constraints.
principle-ddd
Domain-Driven Design (DDD) — bounded contexts, entities, domain events, and repository pattern. Auto-load when modeling a complex domain, microservice splits, designing aggregates, or aligning code with business language.
principle-design-patterns
Design patterns — Gang of Four and beyond. Strategy, factory method, observer, adapter, template method, dependency injection. Auto-load when designing class structure, or evaluating whether a pattern applies.
principle-distributed-systems
Distributed systems principles — CAP, consistency models (linearizable, causal, eventual, read-your-writes), quorum, leader election, partitioning, idempotency across nodes, fallacies of distributed computing. Auto-load when reasoning about CAP/PACELC trade-offs, choosing a consistency model, ordering events with logical clocks, distinguishing exactly-once delivery from exactly-once effects, designing replication or partitioning strategy, or assessing distributed failure modes.
principle-error-handling
Error handling principles — errors as values vs exceptions, wrapping and context chains, retry with exponential backoff and jitter, circuit breakers and bulkheads, log-once boundary discipline. Auto-load when discussing errors as values, retry, exponential backoff, jitter, fail fast, fail soft, idempotent retry, error wrapping, or deadlines.
principle-event-driven
Event-driven architecture — event sourcing, CQRS, sagas, schema evolution, consumer groups, partitions, idempotent handlers, outbox pattern, dead letter queues. Auto-load when designing event-driven systems, evaluating event sourcing or CQRS, planning saga workflows, implementing idempotent consumers or the outbox pattern, managing dead letter queues, or assessing whether event-driven architecture fits the problem.
principle-i18n
Internationalization (i18n) & localization (l10n) principles — locale-aware date, time, time-zone correctness (persist UTC in DB, render local), CLDR plural rules, message catalogs (ICU MessageFormat, gettext), translatable string composition (no concatenation), bidirectional & right-to-left layout. Auto-load when adding a new locale, formatting dates/times/numbers/currency for display, persisting timestamps, building message catalogs, composing user-facing strings from variables, working with right-to-left scripts, choosing between backend and frontend locale negotiation, or auditing UI-string translation readiness.
principle-observability
Observability principles — logs vs metrics vs traces, structured logging, distributed tracing, span/trace context, cardinality control, SLI/SLO/SLA, RED method, USE method, alerting on symptoms vs causes. Auto-load when adding logging, choosing a metric, instrumenting distributed tracing, defining SLIs/SLOs, designing alerts, or discussing observability budgets.
principle-performance
Performance engineering principles — latency vs throughput, profile-before-optimize discipline, Big-O instincts for common patterns, data locality and cache-friendliness, N+1 queries on a list endpoint, TTL sizing for hot-path endpoints, stampede prevention with single-flight. Auto-load when reviewing hot-path code, choosing data structures, designing batch or streaming pipelines, hunting allocations or GC pauses, sizing TTL and picking cache invalidation, or evaluating scalability.
principle-postmortem
Postmortem principles — blameless culture, root cause analysis (5 Whys, Fishbone), incident document structure, MTTD/MTTR metrics. Auto-load when running a blameless review, facilitating RCA, tracking action items after an outage, or improving incident response processes.
principle-product-design
UX and product design principles — Nielsen's 10 usability heuristics, visual hierarchy, interaction design patterns, design-system compliance, and responsive layout. Accessibility/WCAG conformance is delegated to `swe-workbench:principle-accessibility`. Auto-load when reviewing UX, evaluating usability, assessing visual hierarchy or information architecture, auditing design-system compliance, or planning user-facing features.
principle-refactoring
Refactoring discipline — Fowler's catalog of behavior-preserving moves (Extract Function, Inline Variable, Move Function, Replace Conditional with Polymorphism, Introduce Parameter Object, Extract Class), the rule of three, characterization-tests-before-touching-legacy, and small-steps-with-green-between discipline. Distinct from principle-clean-code (naming/length aesthetics) and principle-design-patterns (GoF catalog selection). Auto-load when discussing refactoring strategy, code smells, characterization tests for legacy code, or behavior-preserving structural change.
principle-resiliency
Resiliency principles — fault tolerance, partial failure, failure domains, bulkheads, fail-fast vs fail-soft, health checks, liveness vs readiness probes, idempotency keys, safe retry, deduplication, exactly-once effects, token and leaky buckets, synchronized retries, and 429 responses. Auto-load when isolating dependencies with bulkheads, choosing fail-fast vs fail-soft, configuring health/readiness/liveness probes, making operations safely retryable with idempotency keys or dedup stores, preventing double execution, or adding jitter to prevent thundering-herd retry spikes.
principle-security
Security design principles — trust boundaries and input validation, secure defaults and defense in depth, lightweight threat modeling, cryptography hygiene, RBAC/ABAC authorization models, OAuth 2.0/OIDC token validation. Auto-load when designing auth, discussing authn or authz, handling secrets or credentials, defining trust boundaries, validating untrusted input, considering SSRF or CSRF, configuring TLS, weighing least-privilege trade-offs, choosing RBAC or ABAC, handling PII or GDPR data, or pinning deps and generating an SBOM.
principle-solid
SOLID principles — SRP, OCP, LSP, ISP, DIP (single responsibility, open-closed, Liskov substitution, interface segregation, dependency inversion). Auto-load when designing classes, or discussing coupling, abstractions, or any SOLID violation.
principle-tdd
Test-Driven Development (TDD) — red-green-refactor, spec first, Arrange-Act-Assert; making tests fast and isolated; test doubles (mock, stub, fake, spy), mocking-as-design-feedback, outside-in vs inside-out TDD. Auto-load when implementing a feature TDD-style, fixing a bug with tests, or writing the test before the implementation.
principle-testing
Testing strategy and architecture — test pyramid (unit / integration / e2e), test doubles taxonomy (stub / mock / spy / fake), coverage-vs-confidence, mutation testing, flaky-test triage, contract testing, fixtures and test data builders. Distinct from principle-tdd which covers the red-green-refactor micro-cycle. Auto-load when discussing test strategy, mock vs real dependency, coverage adequacy, test pyramid balance, flaky test diagnosis, or test architecture.
principle-version-control
Version control & collaboration hygiene — atomic commits (one logical change), commit-message quality (imperative subject, body explains why), branching strategy (feature-branch vs trunk-based), rebase vs merge trade-offs. Auto-load when discussing commit hygiene, writing commit messages, choosing a branching strategy, debating rebase vs merge, deciding when to squash, or reviewing PR description quality.
ticket-context
Fetch ticket context from Jira (PROJ-123), Linear, Confluence, or GitHub (`#NNN`). Auto-loads on ticket references. Returns title, summary, acceptance criteria, links, and recent activity.
principle-data-modeling
Data modeling — relational vs document vs KV vs graph selection, normalization depth, indexing strategy, hot-key avoidance, schema evolution via expand–contract, query-first design, retention and archival. Auto-load when designing schemas, schema evolution, indexing strategy, hot-key avoidance, query-first design, or data retention.
principle-release-engineering
Release engineering — semver discipline, rollout strategy, rollback planning, expand-contract for breaking changes, kill-switch, idempotent release automation, post-release verification. Auto-load when cutting a release, planning a breaking API change, writing release notes, choosing a version bump, using a feature flag as a kill-switch, or building release automation scripts.
workflow-codebase-knowledge
Use to understand an unfamiliar codebase — presents architecture overview, module map, public API surfaces, and conventions as a layered mental model. Knowledge-presentation only — read-only sweep, no defect ranking, no reasoning chains. Distinct from workflow-codebase-audit (finding-oriented defect detection) and tech-writer / /swe-workbench:document (generates new prose artifacts). Ideal for onboarding, knowledge-handoff, and reviewer context-gathering.
comms-context
Fetch on-call and discussion context from Slack threads and PagerDuty incidents — participants, timeline, and status. Auto-loads on Slack permalinks or PagerDuty incident references. Keywords — Slack, thread, PagerDuty, on-call.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.