bsene

@bsene source repo

46 skills
0 followers
15 hours ago last updated

▌
Testing 2 · bsene bundle
Go testing — table-driven tests, test helpers, benchmarks, fuzz testing, profiling, and testify. TRIGGER when: user asks about Go testing, go test, testing package, table-driven tests in Go, Go test helpers, t.Helper, t.Run, Go benchmarks, Go profiling, pprof, Go fuzz testing, Go test coverage, testify, Go mock, Go test patterns, Go test organization, TestMain, t.Cleanup, t.Parallel, Go golden files, Go httptest. DO NOT USE when: user needs general testing philosophy (not Go-specific) — use `testing` skill instead.

0
installs
▌
PHP · bsene
Write, review, debug, or explain PHP code. Use whenever the user mentions PHP, .php files, Composer, PSR standards, or PHP frameworks (Laravel, Symfony, etc.), or asks about PHP language features, functions, or syntax. For anything beyond common knowledge — exact function signatures, parameter order, return types, edge-case behavior, deprecations, or version differences — verify against the official documentation at https://www.php.net/ (e.g. function pages like https://www.php.net/manual/en/function.array-filter.php) rather than relying on memory.

0
installs
▌
Kano · bsene bundle
Kano Model feature triage: classify features as Must-be, One-dimensional, Attractive, Indifferent, or Reverse before building them. Empowers developers to refuse unnecessary work with a principled, evidence-based framework. TRIGGER when: user says Kano, "should we build this?", "is this feature worth it?", "feature prioritization", "feature triage", "must-have vs nice-to-have", "feature classification", "refuse this feature", "say no to features", "build the right thing", "feature factory"; user wants to decide whether a feature is worth implementing; user questions the value of a story or ticket before starting work. DO NOT USE when: the decision is already made and the question is purely implementation technique (use `tcrdd` or `testing` instead); performing market research or competitive analysis; the user needs help writing tests or code. Prefer this over `tcrdd` when the question is "should we build this?" rather than "how should we build this?"

0
installs
▌
Ruby · bsene bundle
Write, review, and improve Ruby and Rails code — idiomatic style (duck typing, Enumerable, judicious metaprogramming), GoF design patterns applied the Ruby way (Strategy, Observer, Template Method, Decorator, Factory, Singleton, Adapter, Proxy, Composite, Command, Builder, and DSLs), and testing (RSpec/Minitest structure, mocking discipline, FactoryBot, Rails test-pyramid layering, mutation and property-based testing for high-risk code). Use whenever the user writes, reviews, or refactors Ruby or Rails code; asks "is this idiomatic" or "what pattern fits"; ports code from Java, C#, TypeScript, or Python that still reads like the source language; picks between a class, module, Struct, or block; weighs mocking vs. real objects; or judges a Rails concern/service object/PORO.

0
installs
▌
Ocaml · bsene bundle
Write, review, debug, and explain OCaml code and dune projects. Use whenever the user mentions OCaml, .ml/.mli files, dune, dune-project, opam, Alcotest, qcheck, mutaml, camelot, dead_code_analyzer, property-based testing, mutation testing, katas or exercises written in OCaml, or asks to convert JS/TS/PHP logic into OCaml. Trigger even if the user just pastes OCaml code with a compiler error and asks "what's wrong here", asks to set up a new dune project, or asks for the OCaml idiom for something they already know how to do in JS/TS. The user is an experienced JS/TS/PHP developer but a genuine OCaml beginner — explanations should assume strong general programming skill and zero OCaml-specific knowledge, never the reverse.

0
installs
▌
Tcrdd · bsene
Test-Commit-Revert + TDD (TCRDD): red/green/refactor with per-phase auto-commit on success and auto-revert on failure, gated by user approval before code and before committing. TRIGGER when: user says TCRDD, TCR, TDD, red-green-refactor, "test-first", "write the test first", "let's TDD this", "baby steps", "commit on green", "revert on failure", or "go step by step with tests"; user wants approval-gated pair programming or a disciplined test-then-code cadence with automatic commits. DO NOT USE when: retrofitting tests onto existing code without behaviour change (use `testing`); one-off bug fix where per-phase commits add noise; no runnable test command; trivial code covered indirectly by other tests; GUI/layout fiddling; throwaway scripts; or thin wrapping of a trusted third-party framework you aren't testing internally. Prefer this over `testing` when cadence and commit discipline matter, not just test authoring.

0
installs
▌
Golang · bsene bundle
Idiomatic Go — error handling, concurrency, web services, testing, and project structure. TRIGGER when: language (Go, Golang, .go files, go mod, go build, go run, go test, go fmt), concurrency (goroutine, channel, sync, context, select statement), errors (error interface, error wrapping, sentinel errors, panic/recover, errors.Is/As), web (net/http, HTTP handler, JSON encoding, REST API in Go, middleware), idioms (defer, nil, pointers vs values, struct embedding, interface satisfaction, receiver methods, slices, maps), tooling (Go modules, generics, table-driven tests, go vet), ask (idiomatic Go, Go best practices, Go code review, how to write Go). DO NOT USE when: user mentions "go" only as a verb in a different-language context.

0
installs
▌
Review · bsene bundle
Reviews current branch changes: reads the actual diff, produces structured feedback (Blockers / Concerns / Nits), asks targeted questions, then applies fixes on approval. TRIGGER when: user says "/review", "review this PR", "review my changes", "code review", "review the diff", "PR review", "review branch", "what do you think of my code", "look at my changes", "give me feedback on this". DO NOT USE when: user wants to understand what changed without requesting feedback; user asks for explanation only; no commits exist on current branch beyond main.

0
installs
▌
Simple · bsene
Use this skill whenever writing new code, proposing a bugfix, reviewing a PR/diff, or discussing whether to add an abstraction, config layer, plugin system, or generic mechanism. Also trigger for architecture/design discussions, is this too complex" questions, or any point where Claude is about to suggest introducing a new abstraction layer. The core stance — code is written for humans to read, not as an artwork to admire — optimize for affordance (like a road sign, instantly readable) rather than elegance or cleverness. Trigger even if the user doesn't name "simplicity" explicitly — e.g. "should I make this configurable", "quick fix for this bug", "review this PR", "should I abstract this into a helper", "this codebase feels messy".

0
installs
▌
Monoids · bsene
Recognize and apply the monoid abstraction (binary associative operation + neutral element) in Clojure/ClojureScript code. Use whenever the user is combining, aggregating, merging, or reducing data — metrics and counters, event logs, config objects, or any `reduce`/`fold`/`merge-with` over a collection — even if they don't use the word "monoid". Also use when reviewing code that special-cases empty lists/collections, when discussing Map-Reduce or parallel aggregation (including `pmap`-based reduction), or when designing a generic `combine`/`merge`/`empty` API instead of ad hoc merge logic. Trigger this for "how do I merge these two X" or "what's a clean way to aggregate Y" style questions, not just explicit monoid/algebra questions. For TypeScript idioms, route to the `typescript` skill instead.

0
installs
▌
Testing · bsene bundle
Testing strategy and philosophy — design feedback, test quality audit, BDD review, architecture decisions, and test strategy for AI coding agents. TRIGGER when: strategy (testing approach, philosophy, methodology, how should I test, what tests to write), portfolio (unit, integration, component, contract, E2E, testing layers, how much to test), quality (brittle/flaky/slow/hard-to-maintain tests, testing anti-patterns, can I trust this test), mocking (when to use mocks, test doubles, stubs, fakes), review (review my test suite, BDD review), context (testing legacy codebase, adding tests to existing code), production (QA in production, synthetic monitoring, observability, exploratory testing), LLM applications (testing LLM systems, prompts, retrieval, evaluation suites), AI agents (testing strategy for AI-generated code, should the AI write its own tests, multi-agent testing). DO NOT USE for interactive TDD cadence with red/green/refactor loops — use `tcrdd` instead. DO NOT USE for smoke tests specifically — use

0
installs
▌
Dantotsu · bsene bundle
Use this skill when the user wants to investigate a bug, defect, incident, or quality issue and find its root cause — including requests to run a "5 whys" analysis, write a postmortem, do a root-cause analysis (RCA), figure out why a bug reached production or slipped past code review/QA, set up a recurring defect-analysis routine, or run a daily/weekly quality-improvement (Kaizen) triage. Also known as the Dantotsu method (Sadao Nomura's Toyota-derived defect-analysis approach, adapted for software). Trigger even if the user doesn't name the method explicitly — e.g. "why did this bug get through code review", "a client reported a bug, help me analyze it", "I want to understand why this keeps happening", "write up a root cause report for this defect", or "help me prioritize which fixes to actually ship this week".

0
installs
▌
Git Hero · bsene bundle
Git best practices — commit discipline, branching/history hygiene, safety, and CI/CD pipelines. Routes to `git-guru` (expert Q&A), `gitmoji`, and `gitlab-dag` sub-skills. TRIGGER when: commits (Conventional Commits, atomic commits, commit message format, commit hygiene, commit types, scope selection, breaking change), history (branch naming, rebase vs merge, clean git history, interactive rebase, history management), safety (force push safety, recover lost commits, reflog, reset), CI/CD (GitLab CI, pipeline optimization, DAG, .gitlab-ci.yml), emoji (gitmoji, commit emoji, "quel emoji pour ce commit"), setup (git configuration, "bonnes pratiques git", "comment faire un rebase", "configure git properly"). DO NOT USE when: user needs a single one-shot git command answer — let Claude answer directly.

0
installs
▌
Markdown · bsene bundle
GitHub Flavored Markdown (GFM) syntax reference — tables, alerts, footnotes, task lists, links, images, mentions, anchors, escaping, and common pitfalls. TRIGGER when: user asks about GFM, github flavored markdown, markdown syntax, md syntax, github markdown formatting, markdown table, markdown heading, markdown link, markdown image, task list syntax, markdown alert, GitHub callout, footnote markdown, markdown line break, markdown emoji shortcode, escape markdown special chars, section anchor, autolink. DO NOT USE when: user is composing prose content in markdown and needs no syntax help — only invoke when the question is about rendering, syntax correctness, or feature availability.

0
installs
▌
Rescript · bsene bundle
Write, review, debug, and explain ReScript code and rewatch projects. Use whenever the user mentions ReScript, .res/.resi files, rescript.json or bsconfig.json, rewatch, rescript build/watch/format, npx create-rescript-app, @rescript/core, @rescript/react, @react.component, JSX version 4, rescript-jest, rescript-test, uncurried functions, genType, variant/record/dict literals, or migrating ReScript 11 to 12 — or asks to set up a ReScript project, bind to a JS library, or translate JS/TS logic into ReScript. Trigger even if the user never says "ReScript" and just pastes .res code with a compiler error asking "what's wrong here", or asks for the ReScript equivalent of something they already know from JS/TS. The user is an experienced JS/TS/PHP developer but a genuine ReScript beginner — explanations should assume strong general programming skill and zero ReScript-specific knowledge, never the reverse.

0
installs
▌
C4 Diagram · bsene bundle
Generates C4 model architecture diagrams using Structurizr DSL (primary) or Mermaid C4 (fallback). Use when: user asks to "draw a diagram", "create a C4 diagram", "show architecture as a diagram", "generate architecture diagram", "document the system", or when explain-code reaches its diagram step. DO NOT USE for code explanation or walkthroughs (use `explain-code`), class/sequence/ER diagrams (C4 is system-architecture only), or when a diagram is incidental to a code change — only when a C4 diagram is the primary deliverable.

0
installs
▌
Clean Code · bsene
Use when writing new code, naming modules/files/functions/classes/variables, reviewing or refactoring code for readability, or assessing/reducing function complexity. Trigger on requests like "name this function", "is this a good variable name", "review this for clean code", "reduce complexity", "should I add a comment here", or any PR/code review pass. Covers naming conventions, cyclomatic complexity budgets (human vs agent-authored code), and comment discipline. Not a full style guide — pairs with language-specific skills (typescript, go, clojurescript) for syntax/idiom concerns.

0
installs
▌
Web · bsene bundle
Go web development — HTTP server, handlers, middleware, routing, JSON encoding, XML, templates. TRIGGER when: user asks about Go HTTP server, net/http, Go handler, Go middleware, Go routing, Go JSON, encoding/json, json.Marshal, json.Unmarshal, Go XML, Go templates, html/template, Go REST API, Go web service, http.ListenAndServe, http.HandlerFunc, Go request handling, Go response writer, Go ServeMux, Go router, chi router, Go graceful shutdown, Go HTTP client. DO NOT USE when: non-web JSON/struct marshaling or general Go with no HTTP server/handler/router → use the relevant `golang` sub-skill; non-Go web work.

0
installs
▌
Typescript · bsene bundle
JavaScript & TypeScript best-practices and rule enforcement — JS idioms (naming, `this`-handling, module structure, nullability, iteration performance) and TS-specific type safety, runtime validation, and error handling. Routes to type-system and Zod sub-skills and `object-oriented-programming` for design patterns and SOLID. TRIGGER when: language (TypeScript, TS, .ts, .tsx, JavaScript, JS, .js, .mjs, .cjs, Node.js, browser JS, ESM, CommonJS), type-system (discriminated unions, generics, utility types, make illegal states unrepresentable, type narrowing, variance, contravariance), safety (strict mode, any vs unknown, ts-expect-error, ts-ignore, type assertions, noUncheckedIndexedAccess, noImplicitReturns), runtime (Zod, schema validation, runtime type checks, parse/safeParse), errors (error handling without throwing, union return errors, Result type), ts-conventions (readonly modifier, return type annotations, module organization, namespace, export default, interface prefix, `.d.ts`, ambient declaration, decl

0
installs
▌
Refactoring · bsene bundle
Detect code smells and apply *in-place* refactoring techniques (Extract Method/Class, Replace Conditional, Introduce Parameter Object, Rename, Move) to improve clarity, testability, and maintainability of a single function, class, or file. TRIGGER when: user mentions refactoring opportunities, code smell, long method, large class, primitive obsession, long parameter list, data clumps, feature envy, shotgun surgery, switch statement smell, extract method, extract class, replace conditional with polymorphism, introduce parameter object, simplify single file, improve readability, tidying, tidy first, "clean up this function", "refactor this class". DO NOT USE when: no tests exist (unsafe to refactor blind — add tests first), the change is behavior-altering rather than structure-only (use `tcrdd` instead), or the user needs to safely untangle a *cross-file* dependency graph where one change ripples to many call sites (use `mikado-method` instead).

0
installs
▌
Smoke Tests · bsene bundle
Smoke test identification, authoring, and CI integration for HTTP APIs — using Hurl or curl only. TRIGGER when: smoke test, smoke testing, critical path test, CI gate, gate before full suite, write smoke tests, add smoke test, smoke test template, which tests are smoke tests, hurl, .hurl file, curl smoke test. DO NOT USE when: user needs full testing strategy or philosophy — use `testing` instead.

0
installs
▌
Explain Code · bsene
Explains code with C4 model diagrams, analogies, and step-by-step walkthroughs. Use when explaining how code works, teaching about a codebase, onboarding to architecture, or when the user asks "how does this work?", "explain this system", "walk me through this", "what does this code do?", "help me understand this", "show me the architecture", "explain this service", "how is this structured?", "trace the flow", "what happens when X calls Y?", or is new to a codebase and needs orientation. DO NOT USE when: a one-sentence answer suffices — only invoke when an architecture overview, diagram, or step-by-step code walkthrough is the actual need.

0
installs
▌
Clojurescript · bsene bundle
Write, review, debug, and configure ClojureScript code and projects. Use this whenever the user mentions ClojureScript, .cljs/.cljc files, shadow-cljs, figwheel, the CLJS compiler, JS interop from Clojure, Reagent/re-frame/Reagent-style UI code, or asks to convert JS/TS logic into ClojureScript. Also use it for questions about CLJS compiler options (:optimizations, :main, :npm-deps, :externs, etc.), consuming JS/npm libraries from CLJS, source maps, Google Closure Library usage, or the newer ^:async/await function support. Also trigger for CLJS recursion/stack-overflow/trampoline questions. Trigger even if the user just pastes CLJS code with an error and asks "what's wrong here" or asks to set up a new CLJS project. Do NOT use for nbb (babashka/nbb) scripts, `nbb.edn` projects, or anything meant to run via `nbb script.cljs`/`npx nbb` — those have a different (SCI-interpreted, no-Closure-Compiler) language surface; those are out of scope for this skill — consult nbb's own documentation.

0
installs
▌
Communication · bsene bundle
Analyze a real communication artifact (Slack/Teams message, email, meeting transcript, pitch or presentation draft) and coach it sharper using seven rhetoric + structure techniques: ethos/logos/pathos, reframing tough questions, centering the other person, the Pyramid Principle, pattern interrupt, making ideas feel safe, and the cognitive-load through-line. Diagnose what works, what's missing, then rewrite. TRIGGER when: user wants to improve communication, "make this message clearer", "review my email/Slack", "analyze this transcript", prep for a meeting/pitch/presentation, "how do I say this", be more convincing / persuasive / assertive, handle a tough question, talk to executives, structure my idea, "is this too long-winded". Also trigger for style presets: "rewrite this like DHH" / "in the style of David Heinemeier Hansson" / "make it blunt/direct" (see references/dhh-style.md). DO NOT USE for raw text generation with no analysis, marketing/copywriting, translation, or code/docs — use `kano` for feature d

0
installs
▌
Cupid Checker · bsene bundle
Review code against the CUPID properties for joyful coding: Composable, Unix philosophy, Predictable, Idiomatic, and Domain-based. Use this skill whenever the user wants to assess code quality using CUPID, asks "is this code CUPID?", wants a code review framed around CUPID principles, mentions any of the five CUPID properties by name, asks how to make code more joyful or habitable, or wants to refactor/improve code using Dan North's CUPID framework. Also trigger when the user pastes code and asks for feedback on structure, naming, dependencies, predictability, or domain alignment — even if they don't explicitly mention CUPID. DO NOT USE when: user wants specific refactoring techniques for code smells — use `refactoring` instead. DO NOT USE when: user wants SOLID principle analysis — use `object-oriented-programming` instead.

0
installs
▌
Mikado Method · bsene bundle
Enforce and guide the Mikado Method for *large, graph-driven* refactors where a single naive change cascades into many failing call sites. The skill enforces the full Mikado loop: goal → naive attempt → map prerequisites → revert → implement leaves → commit → repeat. TRIGGER when: user mentions Mikado Method, dependency untangling, circular dependencies, "breaking everything" on a refactor, change cascading across many files, ripple effects, large-scale legacy refactor with tight coupling, untangling tightly-coupled modules, splitting a big refactor into safe steps, or wanting to work on main without a long-lived feature branch. Also trigger on "graph-based refactor", "prerequisite tree", or "Mikado graph". DO NOT USE when: the change is small/in-place (single method, single class, simple rename) — use `refactoring` instead for code smells and Extract Method-style work. If the feature hasn't been scoped yet, consider `kano` first to validate it's worth doing.

0
installs
▌
Chicken Scheme · bsene bundle
Write, compile, debug, and package CHICKEN Scheme programs. Use this skill whenever the user mentions CHICKEN Scheme, call-cc.org, csc, csi, Scheme eggs, Scheme-to-C compilation, R5RS/R7RS Scheme, call/cc, continuations, SRFI, or wants help with any Scheme programming task using CHICKEN. Also trigger for questions about the CHICKEN FFI, C interop from Scheme, egg packaging, REPL usage, or scripting with csi. Even if the user just says "scheme" without specifying CHICKEN, use this skill if context suggests CHICKEN (e.g. they mention eggs, csc, chicken-install, or wiki.call-cc.org). DO NOT USE when: the user is working with another Scheme implementation (Racket, Guile, MIT Scheme, Gambit) — those have different module systems, package managers, and idioms.

0
installs
▌
Zod · bsene
Zod v4 best practices — schema design, error handling, transforms, coercion, branded types, and boundary validation. Reference bundle for the `typescript` skill; not independently triggered.

0
installs
▌
REST API Design · bsene
REST API design best practices — URI naming, HTTP verbs/status codes, pagination, filtering, error envelopes, versioning, security. Based on Octo's API design guide with modern updates. TRIGGER when: designing REST API, designing endpoint, API design review, URL design, resource naming, HTTP verb choice, status code choice, pagination strategy, cursor vs page pagination, error format, response envelope, API versioning, REST conventions, RESTful, "/users vs /user", PATCH vs PUT, 201 vs 200, 400 vs 422, idempotency key, rate limiting headers, expand/include parameter, HATEOAS, OAuth2, reviewing routes/controllers/handlers. DO NOT USE when: GraphQL, gRPC, WebSocket, or RPC-style APIs; pure backend logic unrelated to HTTP surface; OpenAPI/Swagger tooling questions only (use generic tools).

0
installs
▌
Gitmoji · bsene bundle
Selects and applies gitmoji emoji prefixes for Git commit messages, integrated with Conventional Commits format. Use when the user asks about gitmoji, wants an emoji for a commit message, asks 'which emoji for...', 'quel emoji pour...', mentions commit emoji conventions, says 'prefix my commit', 'gitmoji for', 'emoji commit', or wants to decorate commit messages with standardized emoji. DO NOT USE when: the user wants plain Conventional Commits with no emoji; general Git help → use git-hero-git-guru.

0
installs
▌
Show Me The Code · bsene
Enforces one rule: every code change must be presented as a unified diff (`diff -u` format) with 3 lines of context. No exceptions, even one-liners. TRIGGER when: user requests a code modification — fix, refactor, update, replace, edit, patch, change, tweak, rename, rewrite, apply changes, modify this, edit the file, change this code, or explicitly asks for a diff — "show me the diff", "as a unified diff", "what changed", "show the patch", "/show-me-the-code". DO NOT USE when: producing a brand-new file from scratch (no context lines to diff against), or for non-code responses such as plans, explanations, architecture, or diagrams.

0
installs
▌
Git Guru · bsene bundle
Expert Git assistant that answers questions about Git concepts, commands, workflows, and best practices — both in French and English. Use this skill whenever the user mentions Git, version control, commits, branches, merges, rebases, conflicts, stash, push/pull, remotes, history rewriting, or anything related to source code versioning. Also trigger when users say things like 'comment faire un rebase', 'I messed up my history', 'explain branching strategies', 'how do I undo a commit', 'what is the difference between merge and rebase', 'git tips', 'commit message best practices', or any git-related question — even phrased casually or in French. DO NOT USE when: choosing a commit-message emoji → use git-hero-gitmoji; designing/optimizing GitLab CI pipelines → use git-hero-gitlab-dag; non-Git version control (SVN, Mercurial, Perforce).

0
installs
▌
Concurrency · bsene bundle
Go concurrency — goroutines, channels, select, sync primitives, context, and data race prevention. TRIGGER when: user asks about goroutines, Go channels, Go select, sync.Mutex, sync.WaitGroup, sync.Once, Go context, context.WithCancel, context.WithTimeout, Go data race, race condition in Go, Go concurrency patterns, fan-in fan-out, worker pool, Go channel direction, buffered channel, Go deadlock, -race flag, errgroup, Go concurrent map, Go goroutine leak. DO NOT USE when: user needs general concurrency theory unrelated to Go, or is asking about goroutines only as background context with no code to write or review.

0
installs
▌
Init · bsene bundle
Creates, updates, or optimizes an AGENTS.md file for a repository with minimal, high-signal instructions covering non-discoverable coding conventions, tooling quirks, workflow preferences, and project-specific rules that agents cannot infer from reading the codebase. Use when setting up agent instructions or Claude configuration for a new repository, when an existing AGENTS.md is too long, generic, or stale, when agents repeatedly make avoidable mistakes, or when repository workflows have changed and the agent configuration needs pruning. Applies a discoverability filter—omitting anything Claude can learn from README, code, config, or directory structure—and a quality gate to verify each line remains accurate and operationally significant.

0
installs
▌
Gitlab Dag · bsene bundle
Design, write, review, or optimize GitLab CI/CD pipelines using DAG (Directed Acyclic Graph) with the needs keyword and parallelism features (parallel, parallel:matrix). Use this skill whenever the user mentions GitLab CI, .gitlab-ci.yml, pipeline optimization, job dependencies, the needs keyword, parallel matrix builds, pipeline speed, or wants to break free from strict stage ordering. Also trigger when the user asks about reducing CI runtime, fanning out jobs, matrix builds across OS/version/environment combinations, or 1:1 job dependency mapping between matrix jobs. DO NOT USE when: non-GitLab CI systems (GitHub Actions, CircleCI, Jenkins, Azure Pipelines); general Git questions → use git-hero-git-guru.

0
installs
▌
Error Handling · bsene bundle
Go error handling — error interface, custom error types, wrapping, sentinel errors, errors.Is/As, panic/recover. TRIGGER when: user asks about Go error handling, if err != nil, custom errors, error wrapping, fmt.Errorf %w, errors.Is, errors.As, sentinel errors, panic recover, when to panic in Go, error types in Go, Go error best practices, Go error propagation, error chains, Go error interface, handling errors in Go, Go error patterns. DO NOT USE when: user needs general error-handling philosophy outside Go, or panic/recover questions unrelated to Go's error interface.

0
installs
▌
Logging Daily Progress · bsene bundle
Maintains a rolling daily progress log (`progress-daily.md`) that captures Impact, Learnings, and Commits for each day of engineering work, sourced from git history. Author identity and log path are configurable per repo. TRIGGER when: user says "log today", "log my day", "any updates?", "what did I ship?", "update my progress log", "add today to the hype doc", "recap this week from git", "catch me up on what I shipped", or "backfill since <date>". Also trigger when the user mentions Impact/Learnings/Commits journaling, the Career Hype Doc practice, or wants daily wins recorded while context is fresh rather than reconstructed later from calendar archaeology. DO NOT USE when: the user wants a one-off git log query (use `git log` directly) or a release-notes-style changelog (different audience, different format).

0
installs
▌
Composition · bsene
Functional programming composition in JavaScript/TypeScript — pipe/compose, currying, point-free, pure functions, factories, functional mixins, monoids. Reference bundle for the `typescript` skill; not independently triggered. For class-based OOP architecture or SOLID principles, the parent routes to `object-oriented-programming`.

0
installs
▌
Type System · bsene
Deep dive into TypeScript's type system — structural typing, type erasure, narrowing, discriminated unions, mapped/conditional types, type guards, branding, and escape hatches. Reference bundle for the `typescript` skill; not independently triggered.

0
installs
▌
Writing A Good Agents Md · bsene bundle
Write, audit, or improve AGENTS.md — the tool-agnostic context file for coding agents — plus harness adapters (CLAUDE.md, .cursorrules, GEMINI.md, Copilot instructions). Use when creating one from scratch, auditing for bloat or anti-patterns, consolidating multiple tool files into one source of truth, or applying progressive disclosure.

0
installs
▌
Packages And Modules · bsene bundle
Go modules and packages — go.mod, go.sum, versioning, proxies, internal packages, init functions. TRIGGER when: user asks about Go modules, go mod init, go mod tidy, go.mod, go.sum, Go package organization, Go imports, Go internal package, Go init function, Go module proxy, Go versioning, Go major version, Go replace directive, Go workspace, Go vendor, Go dependency management, GOPATH vs modules, GOPROXY, GOPRIVATE, go install vs go get. DO NOT USE when: user is asking purely about directory/folder layout (cmd/, internal/, pkg/) with no go.mod, versioning, or dependency question involved — use the `golang` skill's Project Layout reference directly instead.

0
installs
▌
Types And Interfaces · bsene bundle
Go type system — structs, interfaces, embedding, composition, generics, slices, maps, enums with iota. TRIGGER when: user asks about Go structs, Go interfaces, Go embedding, composition in Go, Go generics, type parameters, Go type constraints, Go slices, Go maps, Go iota, Go enum, Go bitmask, implicit interface, interface satisfaction, small interfaces, accept interfaces return structs, Go type assertion, Go type switch, when to use generics in Go, Go collections, Go struct tags, Go composition vs inheritance, Go polymorphism. DO NOT USE when: user asks about OOP design principles or composition/polymorphism in a language-agnostic way with no Go code involved — use `object-oriented-programming` instead.

0
installs
▌
Object Oriented Programming · bsene bundle
Evaluate and write OOP code — class-shape smells, SOLID, GoF design patterns, Tell Don't Ask, and Object Calisthenics — in TypeScript/Node.js/NestJS. Use for code review, refactoring, or new class/service design. TRIGGER when: class has only static methods; single public method + constructor; invalid until setters are called; data class with only constructor + properties; getters read externally to decide (Tell Don't Ask); GoF pattern names (Decorator/Factory/Strategy/Builder/Command/Observer/Mixin/Proxy/Flyweight/Mediator); SOLID, SRP, OCP, LSP, ISP, DIP, god class, fat interface, reduce coupling, testability; object calisthenics, primitive obsession, first-class collections, one dot per line, Law of Demeter; "is this an OOP anti-pattern?", "should this be a class or a function?", "why does my code feel procedural?", or a stricter pass on existing code.

0
installs
▌
Ports Adapters Architecture · bsene bundle
Ports and Adapters (Hexagonal) architecture — isolate business logic from external concerns via explicit boundaries. TRIGGER when: user asks about ports and adapters, hexagonal architecture, hexagon architecture, Alistair Cockburn, clean architecture, onion architecture, layered architecture comparison, adapters (driving/primary adapter, driven/secondary adapter, adapter pattern boundary), ports (inbound port, outbound port, application port), layers (domain layer, application core, infrastructure layer, use case), isolation (dependency inversion in practice, testable business logic, decouple framework, boundary protection). DO NOT USE when: user asks about general OOP/SOLID principles in the abstract — use `object-oriented-programming` instead. Note: DIP from `object-oriented-programming`'s SOLID reference is the theoretical foundation of this pattern.

0
installs
▌
Documentation · bsene bundle
Creates, structures, and reviews technical documentation following the Diátaxis framework (tutorials, how-to guides, reference, and explanation pages). Use when a user needs to write or reorganize docs, structure a tutorial vs. a how-to guide, build reference docs or API documentation, create explanation pages, choose between Diátaxis documentation types, or improve existing documentation structure. Trigger terms include: documentation structure, Diátaxis, tutorials vs how-to guides, organize docs, user guide, reference docs, technical writing.

0
installs
▌
Skill Optimizer · bsene bundle
Optimizes AI skills for activation, clarity, and cross-model reliability. Use when creating or editing skill packs, diagnosing weak skill uptake, reducing regressions, tuning instruction salience, improving examples, shrinking context cost, or setting benchmark/release gates for skills. Trigger terms: skill optimization, activation gap, benchmark skill, with/without skill delta, regression, context budget, prompt salience.

0
installs

46 published skills