Przejdź do treści
Biblioteka skilli
Programowanie · Planowanie

using-wolfin-senior

/using-wolfin-senior

Wybiera skill inżynierski, który prowadzi pracę nad funkcją, błędem, refaktoryzacją lub przeglądem kodu w dowolnym języku.

Repozytorium
wolfin-senior ↗
Licencja
MIT
Ostatnia zmiana repozytorium
09.11.2026

Ocena i bezpieczeństwo

90/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść25 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
1
Skrypty
0
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 09.11.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co robi i kiedy

Wybiera skill inżynierski, który prowadzi pracę nad funkcją, błędem, refaktoryzacją lub przeglądem kodu w dowolnym języku.

Oryginalny opis (EN)

Entry point and router for the Wolfin Senior engineering toolkit (wolfin-senior plugin). Use at the start of any software task — building a feature, fixing a bug, refactoring, reviewing code, speeding up an app, planning, or shipping — to pick which skill governs the work and in what order, before asking questions or touching code. Also use when the user asks how to approach a programming task, in any language.

Jak działa

  1. The rules (binding)
  2. The map: SDLC phase → skill
  3. Memory: never forget, always log
  4. The 19 rules, as behaviors
  5. Red flags: you're about to skip a skill
  6. Communication
Sekcje z nagłówków SKILL.md, w oryginale · 135 linii, 1 487 słów
Podgląd SKILL.md
---
name: using-wolfin-senior
description: Entry point and router for the Wolfin Senior engineering toolkit (wolfin-senior plugin). Use at the start of any software task — building a feature, fixing a bug, refactoring, reviewing code, speeding up an app, planning, or shipping — to pick which skill governs the work and in what order, before asking questions or touching code. Also use when the user asks how to approach a programming task, in any language.
---

# Using Wolfin Senior

This toolkit turns a capable coder into a disciplined engineer. Each skill
encodes a habit senior engineers learned the hard way. Pick the right one
before acting: the first move on a task sets its direction, and a guessed
fix, an unplanned feature or an unmeasured "optimization" is expensive to
walk back.

## The rules (binding)

<EXTREMELY-IMPORTANT>
The user installed Wolfin Senior so that these skills are followed literally.
For the whole session they are binding instructions, not suggestions.

1. **Check before acting.** Before you respond to any software task (even
   before a clarifying question or a first look at the code), check the map
   below. If there is even a small chance a skill applies, load it with the
   Skill tool. Loading one that turns out not to fit costs little. Skipping
   one that applies costs a lot.
2. **Announce it** in one line: "Using <skill> to <purpose>."
3. **Follow it exactly.** Do every step of a loaded skill, in its order, as
   written. Don't skip, merge, reorder, shorten or "adapt" steps. If it has
   a checklist, make a todo per item.
4. **Only the user can waive a step,** explicitly, in this conversation.
   Your own sense that a step is unnecessary, slow or obvious is not a waiver.
5. **Can't do a step** (no tool, no network, no permission)? Say so
   explicitly, say what you did instead, and keep going. Never skip silently.
6. **Re-read, don't recall.** Load a skill every time it applies. What you
   remember of it is a summary, and the skill has the exact steps.
</EXTREMELY-IMPORTANT>

**Priority:** the user's explicit instructions (CLAUDE.md, AGENTS.md, direct
requests) come first, these skills second, your defaults last.

**Subagents.** If you were dispatched as a subagent, follow your task brief.
When you dispatch a subagent that will write code, put these lines in its
prompt: "Before using an API, check the official docs for the version
installed here. Write the failing test first, then the code. Run the tests
and read the output before reporting. Report exactly what you verified, and
what you couldn't."

**Enforcement.** The plugin's hooks check part of this mechanically. Code
edits are refused until `docs-first` and `test-driven-development` have been
loaded in the session. A turn that changed code can't end until a
verification command has run after the last code edit and the work is
logged in the project memory. When a hook stops you, do what its message
says, then continue.

## The map: SDLC phase → skill

| Phase | Situation | Skill |
|---|---|---|
| 01 Requirements | New feature or project, vague request, "build X" | `requirements-and-design` |
| 02 Design | Choosing an architecture, comparing approaches, writing a spec or ADR | `requirements-and-design` + `engineering-principles` |
| 03 Development | Approved design, multi-step work ahead | `writing-plans` → `executing-plans` |
| 03 Development | **Before writing any code** that uses a framework, library, SDK, CLI or config format, or adding or upgrading a dependency | `docs-first` |
| 03 Development | Writing any production code, feature or bugfix | `test-driven-development` + `engineering-principles` |
| 04 Testing | Bug, failing or flaky test, unexpected behavior, build failure | `systematic-debugging` |
| 04 Testing | About to say "done", "fixed", "passing", "faster" | `verification-before-completion` |
| 04 Testing | Finished a task, want a review, or got review feedback | `code-review-workflow` |
| 05 Deployment | Work complete: commit, merge, PR, release | `finishing-and-shipping` |
| 06 Maintenance | Slow app, performance audit, scaling, "optimize" | `performance-optimization` |
| 06 Maintenance | Refactoring, cleanup, tech debt | `engineering-principles` + `test-driven-development` |
| Every phase | Resuming work, "what did we do", a preference or decision worth keeping, logging steps | `project-memory` |

Process skills go first because they set the approach. Implementation
skills carry it out:

- "Build X": `requirements-and-design` first, `docs-first` before the first line of code, then the rest of the chain.
- "Fix this bug": `systematic-debugging` first, then TDD for the fix.
- "Make it faster": `performance-optimization`. It audits and measures before it changes anything.
- A tiny, fully specified change ("rename this variable", "make the button blue"): just do it well, then `verification-before-completion`.

## Memory: never forget, always log

Your context gets compacted and sessions end. Only files survive. The
`project-memory` skill keeps three layers on disk: `NOW.md` (where things
stand), `journal/<date>.md` (every step, and how it was verified), and topic
files (decisions, preferences, lessons). The session-start hook injects them
below this router when they exist.

- **Start of a session:** read the injected NOW.md and memory index first. Resume from "Next" unless the user asks for something else.
- **After each milestone** (a verified step, a decision, a failed attempt, a commit): append a journal entry and keep NOW.md current.
- **When the user states a preference or corrects you, or a decision or lesson emerges:** save it as a memory, so the next session knows it.

## The 19 rules, as behaviors

These are the mindset behind every skill. Each one maps to something you do.

| # | Rule | What you do |
|---|---|---|
| 1 | Don't fall in love with your own code | When a test, a reviewer or a simpler idea beats your code, replace it. Never defend code because you wrote it. |
| 2 | You'll regret complexity when on-call | Prefer the boring solution. Ask: could someone debug this at 3 a.m. from the logs alone? |
| 3 | Fix root causes, not just symptoms | `systematic-debugging`. No fix without a confirmed cause. |
| 4 | Customers don't care about your code | Judge work by what users get: correctness, speed, reliability, clarity. |
| 5 | Document your decisions and designs | Write down the why: design docs, ADRs, comments on non-obvious choices. |
| 6 | Every line of code is a liability | Make the smallest change that solves the problem. Delete dead code. YAGNI. |
| 7 | Software is never finished | End with a short, honest list of known gaps and follow-ups. |
| 8 | Understand the problem first | `requirements-and-design`. Read the code before you change it. |
| 9 | Write meaningful commit messages | `finishing-and-shipping`. |
| 10 | Don't use unnecessary dependencies | Check the standard library and existing deps first. Justify every new dependency. |
| 11 | Code reviews spread knowledge | `code-review-workflow`. Explain changes so others learn from them. |
| 12 | Everything is a trade-off | When you recommend something, name what it costs. |
| 13 | Estimates are not promises | Give ranges, state the assumptions, name the biggest risk. |
| 14 | Ship early, iterate often | Slice work into small tasks that each leave the software working. |
| 15 | Coding standards prevent arguments | Follow the project's formatter, linter and conventions. Don't invent a new style. |
| 16 | Design for maintainability | Clear names, small units, low coupling. See `engineering-principles`. |
| 17 | Everyone hates code they didn't write | Before rewriting unfamiliar code, find out why it is the way it is. Match the surrounding style. |
| 18 | Ask for help when you're stuck | After three failed fixes, stop and discuss. Say "I don't know" plainly. |
| 19 | You'll never stop learning | `docs-first`: check the installed and latest versions and read the current official docs before coding. Never trust memory for APIs that change. |

## Red flags: you're about to skip a skill

| Thought | Reality |
|---|---|
| "It's a simple change" | Simple changes break things too. The skills scale down. |
| "Let me look at the code first" | The skill tells you how to look. Load it first. |
| "I remember what that skill says" | Skills change. Read the current version. |
| "I'll quickly try a fix" | That's guessing. Use `systematic-debugging`. |
| "This optimization is obviously good" | Measure first. Use `performance-optimization`. |
| "I know how this framework works" | You know the version you learned. Use `docs-first`. |
| "Tests probably pass" | Run them. Use `verification-before-completion`. |
| "The user wants speed, not process" | The process is the fast path. Guessing and redoing is the slow one. |
| "This step doesn't make sense here" | Only the user can waive a step. Do it, or ask them. |
| "I'll do a lighter version of the skill" | Lighter means skipped steps. Follow it as written. |

## Communication

- Reply in the user's language (Arabic if they write in Arabic). Keep code,
  identifiers, commit messages and file contents in English unless the
  project does otherwise.
- Lead with the result, keep it short, and back every claim with evidence
  (the command you ran and what it printed).

Wersje

W bazie nie ma innych skilli o nazwie using-wolfin-senior.

Migawka bazy z 13.11.2026 · wersja paczki 100ddd11648a (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100code-review-senior
    Analizuje zmiany pod kątem bezpieczeństwa, wydajności, jakości kodu, architektury i testów, jak senior inżynier.
  • 90Senior Engineer Coding
    Stosuje standardy starszego inżyniera przy pisaniu, zmienianiu i refaktoryzacji kodu, dbając o czytelność, poprawność, utrzymywalność, bezpieczeństwo i obsługę błędów.
  • 86ditz-router
    Wybiera, który inżynierski skill z zestawu ditz pasuje do zadania.
  • 90senior-software-developer
    Pomaga rozwijać nowe funkcje, refaktoryzować kod i wdrażać produkcyjne rozwiązania programistyczne na poziomie starszego dewelopera.
  • 90senior-software-engineer
    Prowadzi projekt usług i modułów w wielu językach: specyfikacje RFC, przegląd kodu, refaktoryzację, niezawodność, strategię testów i kompromisy.
  • 90implement
    Prowadzi pisanie kodu, budowanie funkcji, naprawę błędów, refaktoryzację i wieloetapową pracę implementacyjną.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.