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.
- Autor
- wolfinApp ↗
- Repozytorium
- wolfin-senior ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 09.11.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 1
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 09.11.2026, bez odwołań do wycofanych modeli i API.
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
- The rules (binding)
- The map: SDLC phase → skill
- Memory: never forget, always log
- The 19 rules, as behaviors
- Red flags: you're about to skip a skill
- Communication
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ą.