oleg494
- 74 skills
- 0 followers
- 3 repo stars
- 6 days ago last updated
- ▌ Dev Wiki · oleg494 bundleUse when prior decisions, project history or preferences could change the answer, or completed work left a durable result: "do you remember", "what did we decide", "save this", "напомни", "запомни", "сохрани". Retrieval with search_all.py and findings.py, plus deterministic save routing — project status to project docs, verified reusable conclusion to findings, portable how-to to the Wiki. Not for current code or fresh research.
- ▌ Ponytail · oleg494 bundleUse for the smallest complete change: "ponytail", "be lazy", "simplest solution", "YAGNI", bloat or over-engineering complaints, or a change that adds an abstraction, a new dependency, a config knob or dead code "just in case". Cuts speculative code, never requested behavior. Not for module, layer or schema decisions (architecture-simplicity) or evidence-based tool choice (production-first-decisions). Levels: lite, full (default), ultra.
- ▌ Fable Judge · oleg494 bundleUse when finished work is claimed done and someone must confirm it independently: "judge this work", "verify what it did", "did the tests really pass", a pasted agent report, a diff or branch to check. Produces an evidence-based verdict (VERIFIED / VERIFIED WITH CAVEATS / REFUTED). Also runs the trap suite via "/fable-judge suite <target>". Not for writing the work itself or for routine code review (use code-review-and-quality).
- ▌ Fable Method · oleg494 bundleUse only for an explicit /fable-method request, or for non-code judgment work it covers: research and source checks, design and UX critique, data analysis, business operations, marketing, finance, legal and compliance. Not for checking a completion claim or eval report (use fable-judge), and not for writing, fixing, debugging or planning code - those follow OPS with the matching engineering skill.
- ▌ Web Research · oleg494Use when a fact from outside the project is needed: "find out", "look up", "what do they say about", "how it works", "compare", "find information", "is this still true". Identify or read the primary source first — open a known URL directly, search only when the owner of the fact is unknown — then cross-check material claims, date them, and answer with links. Not for the local knowledge base or recorded project facts (use dev-wiki) or consequential tool/library decisions (use production-first-decisions).
- ▌ Brainstorming · oleg494 bundleUse when deciding what to build: a new feature, component or subsystem, a vague or conflicted request, a requirement that spans several capabilities, or a product-level design choice with real tradeoffs. Produces intent, constraints, capability map, spec and observable acceptance. Not for service or module structure (architecture-simplicity), consequential tool selection (production-first-decisions), executing already-specified multi-slice work (writing-plans), or non-code judgment work (fable-method).
- ▌ Design System · oleg494 bundleUse when creating or refactoring product UI, landing-page styling, visual direction, shared components, themes, design tokens, or adapting a supplied design reference; dashboard tokens and themes are in scope. Full inventory, state matrix and rendered verification for new or shared components; abbreviated for a local styling change. Not for dashboard information hierarchy, KPI semantics, filters or chart choice (dashboard-design), software architecture, or static illustrations.
- ▌ Writing Plans · oleg494 bundleUse when specified work needs an execution plan or hits a plan defect mid-execution: coupled or multi-slice changes, work split across agents, several independently landable outcomes, or a plan that disagrees with what a slice already shipped. Not for deciding what to build (use brainstorming); not for a single small change.
- ▌ Autonomous Work · oleg494 bundleUse when the user delegates choosing or owning work ("choose useful work yourself", "работай сам", "веди проект как партнёр"), delegates read-only research choice ("сам выбери что исследовать, ничего не меняй"), asks to resume an ongoing mission, continues work under a prior standing grant, or when that grant's scope or expiry is uncertain. Not for ordinary bounded tasks, bounded read-only reviews or plan-only requests (execution plans belong to writing-plans); a scope limit constrains effects, not who chooses the work. Ordinary bounded work follows OPS alone.
- ▌ Skill Authoring · oleg494 bundleUse when creating or editing a skill, or turning a session, procedure or URL into a reusable one ("learn", "/learn", "turn this session into a skill", "make a skill from this workflow", "сделай скилл из этой процедуры", "навык из"): name and description rules, folder layout, script bundling, promotion and retirement evidence. Not for saving conclusions in memory (dev-wiki) or for ordinary code changes.
- ▌ Dashboard Design · oleg494Use when designing, redesigning or reviewing marketplace, seller, operations, finance, logistics or analytics dashboards: information hierarchy, KPI and metric semantics, filters, chart and table choice, honest data visualization, dense layouts, and verifying dashboard states in the running app. Not for product UI, themes, tokens or landing pages (design-system), nor posters or static illustrations.
- ▌ Code Graph Review · oleg494Use when a multi-file change, a rename, or an explicit graph review needs impact analysis — what it breaks, which execution paths it touches, which symbols go dead. Optional helper: works when the code-review-graph MCP and a built graph exist, otherwise native LSP/source search answers direct impact. Not for locating code (use find/grep) and not for judging whether the change is good (use code-review-and-quality).
- ▌ Money Path Safety · oleg494 bundleUse when touching money or quota logic: pay/buy/subscribe, promo or referral codes, balance or limit checks, refunds, or any code that deducts, credits, grants, or expires value — even when the request does not name money ("give me more minutes", "why was I charged twice"). Covers idempotency, three payment outcomes, atomic updates, audit records. Not for plain CRUD without value semantics or live incident diagnosis (systematic-debugging).
- ▌ Testing Discipline · oleg494 bundleUse when writing or fixing tests, working test-first (TDD red-green-refactor), turning a reported bug into a failing test, or choosing a check for a boundary, limit, abuse case, outbound payload or UI flow. Not for diagnosing why something fails (use systematic-debugging) or for the final done claim (use verification-before-completion).
- ▌ Windows Encoding Fixes · oleg494 bundleUse when a script or install fails on Windows text or child-process handling: UnicodeEncodeError or mojibake on ✓/Cyrillic, cp1251 output, CRLF or BOM breakage, md5 mismatch between mirrors, FileNotFoundError from npm, venv bin vs Scripts, winget binaries outside PATH, zip vs tar.gz assets, bash.exe acting as a WSL stub, subprocess decode errors. Not for locating which component failed (systematic-debugging) or Linux-only work.
- ▌ Architecture Simplicity · oleg494Use when designing or reviewing structure: module and layer boundaries, splitting a god file, shared core with thin adapters, where config and defaults live, service boundaries, non-destructive DB schema evolution (expand-contract, backfill, constraints, indexes, rollback), or whether an extra layer is justified. Not for minimalism in one change (ponytail), money logic (money-path-safety), or library choice (production-first-decisions).
- ▌ Code Review And Quality · oleg494 bundleUse when performing a code review — your own, another agent's, or a human's — or dispatching an independent reviewer at a merge boundary or before a major change lands. Covers scope (diff vs whole-system), five review axes, severity counts, the recomputable verdict. Not for received feedback (use receiving-code-review), blast-radius/rename graphs (use code-graph-review), or an adversarial audit of a finished-work claim (use fable-judge).
- ▌ Production First Decisions · oleg494Use before committing to a consequential tool, library, standard or production mechanism: "should we use X", "which library", "is X maintained", auth/crypto/queue/database choices, or replacing a working one. Check project constraints first, then primary-source evidence (docs, changelogs, maintenance signals, issue trackers, benchmarks, own probe) before integration. Not for module structure (architecture-simplicity) or minimalism-only requests (ponytail); ordinary implementation needs no skill.
- ▌ Dispatching Parallel Agents · oleg494Use when several work slices can be handed to separate agents at once: unrelated failures with distinct root causes, independent subsystems, or parallel slices whose interfaces are already defined. Not for related failures or exploratory debugging (investigate inline), and not for deciding slice boundaries or workspace isolation (use writing-plans and using-git-worktrees).
- ▌ Git Workflow And Versioning · oleg494 bundleUse when committing, choosing a branch or base, resolving conflicts, organizing parallel work streams, integrating a finished branch (local merge, PR, keep-as-is), cutting a release, picking a semantic version bump, tagging, or writing a changelog. Not for creating or cleaning up an isolated workspace (use using-git-worktrees) and not for deciding whether the change is correct (use code-review-and-quality / verification-before-completion).
- ▌ Verification Before Completion · oleg494 bundleUse before claiming work is complete, fixed, passing or ready to merge, and before committing or opening a PR: matching the evidence to the type of claim. Not for writing or choosing the checks themselves (use testing-discipline), for diagnosing a failure (use systematic-debugging), or for judging another agent completed work (use fable-judge).
- ▌ Observability And Instrumentation · oleg494Use when adding or repairing logging, metrics, tracing, or alerting so production behavior is visible and diagnosable: a new service or integration, a feature that needs evidence it works, an incident that took too long to diagnose, alerts that page for the wrong thing. Not for release, rollout or rollback decisions (shipping-and-launch).
- ▌ Shipping And Launch · oleg494Use when releasing to production: pre-launch readiness review, staged rollout or canary, feature-flag plan, rollback plan, post-launch verification. Decides what to deploy, at what exposure, and when to reverse it. Not for adding logs, metrics, traces or alerts (observability-and-instrumentation) and not for code-level hardening (security-and-hardening).
- ▌ Using Git Worktrees · oleg494Use when work needs an isolated workspace — concurrent writers or parallel agents, an explicit user request for isolation, or changes that would interfere with the current checkout. Covers detection, native worktree tools before the git fallback, setup, clean baseline, ignore handling, and removing task-created worktrees. Not for every planned change (a bounded single-writer task works in place) and not for merge authority or branch-retention decisions (use git-workflow-and-versioning).
- ▌ Systematic Debugging · oleg494 bundleUse when something fails or behaves unexpectedly: a bug, a failing test or build, a hung or stale process, a service that broke after an update or restart, a zero metric on a feature that looks fine, or "it used to work". Covers root-cause investigation before fixes, boundary evidence and runtime incidents. Not for writing the regression test (use testing-discipline) or the closing claim (use verification-before-completion).
- ▌ Receiving Code Review · oleg494Use when code review feedback arrives and you are about to implement it — especially when an item is unclear, technically questionable, out of scope, or conflicts with an earlier decision. Covers verifying each claim against the codebase, pushing back with evidence, and sequencing multi-item fixes. Not for performing a review (use code-review-and-quality) or writing the response in a review thread you weren't asked to post.
- ▌ Security And Hardening · oleg494 bundleUse when code touches untrusted input, auth, sessions, secrets, uploads, webhooks, third-party APIs, or personal data, and when reviewing a feature for vulnerabilities. Covers STRIDE over trust boundaries, injection, XSS, broken access control, SSRF, input validation, dependency triage, fetched content as data. Not for release and rollback planning (shipping-and-launch) or for choosing telemetry (observability-and-instrumentation).
- ▌ Money Path Safety 2 · oleg494 bundleUse when the user wants to: pay/buy/subscribe, receive or spend a bonus/promo code/referral, check a balance or limit, get a refund, or when any logic for deducting/crediting/quotas changes — even if the request does not name money explicitly («give me more minutes», «why was I charged twice», «enter a promo code»). Checks: idempotency, atomicity, mutation logging, separate buckets, hard gate before expensive work, charge after success, soft delete, compound PK, structured failure. Do not use for pure CRUD without value semantics and for debugging incidents (that is debug-incident-protocol).
- ▌ Testing Discipline 2 · oleg494 bundleUse when adding/fixing tests, reproducing bugs, checking limits or failures, or deciding what evidence establishes completion. Covers isolated storage, real domain logic, meaningful boundary regressions and verification of the affected runtime/UI surface. Debugging strategy lives in debug-incident-protocol.
- ▌ Engineering Persona 2 · oleg494Always-on. Response format rules (not a persona): direct engineering tone, result first, evidence-based, no fluff, no "I would recommend". Code > words. Observation > assumption.
- ▌ Shipping And Launch 2 · oleg494Prepares 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.
- ▌ Using Git Worktrees 2 · oleg494Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
- ▌ Systematic Debugging 2 · oleg494 bundleUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes
- ▌ Receiving Code Review 2 · oleg494Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
- ▌ Requesting Code Review 2 · oleg494Use when completing tasks, implementing major features, or before merging to verify work meets requirements
- ▌ Security And Hardening 2 · oleg494 bundleHardens 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. Use when personal data or privacy compliance (GDPR, CCPA) is involved.
- ▌ Windows Encoding Fixes 2 · oleg494 bundleUse when working with Windows (cmd/PowerShell console, MINGW64, script installation): stdout encoding (cp1251 vs UTF-8, UnicodeEncodeError on ✓/Cyrillic), CRLF/LF when writing files (md5 checks of mirrors), UTF-8 BOM for PowerShell 5.1, npm.cmd instead of npm, venv Scripts vs bin, PYTHONIOENCODING/PYTHONUTF8. Verified against 2 Windows 10 bug reports.
- ▌ Architecture Simplicity 2 · oleg494Use when the user wants to: design/redesign modules and layers, choose between a library and your own code, understand why a project became a god file, add an abstraction "just in case", evolve a DB schema without data loss, or review architecture. Covers: YAGNI until second need, stdlib-first, modules by change reason, shared core + thin adapters, config outside repo + defaults in code, schema evolution without DROP, provider fallback chain, unrepresentable invalid states, deleting dead code. Do not use for money (money-path-safety).
- ▌ Code Review And Quality 2 · oleg494 bundleConducts 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.
- ▌ Debug Incident Protocol 2 · oleg494Use when the user says: «it doesn't work», «still broken», «hung/stuck», «disappeared after the update», «it used to work», «the metric is zero but the UI is fine» — or when an incident needs to be analyzed, the root cause of a hang found, and whether a process was actually restarted verified. Covers: facts before theories (storage/logs/PID), symptom vs root cause, silent failure, restart ritual, localizing hangs with a progress marker, timeouts, cache masking. Do not use for writing tests (testing-discipline).
- ▌ Spec Driven Development 2 · oleg494Creates 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. Use when a single requirement spans several independently testable capabilities.
- ▌ Test Driven Development 2 · oleg494Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.
- ▌ Incremental Implementation 2 · oleg494Delivers 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.
- ▌ Production First Decisions 2 · oleg494Use for consequential choices of tools, libraries, standards or production mechanisms. Check existing project constraints first, research unresolved external facts in primary sources, and test unfamiliar mechanisms before integration. No web-search quota for local facts or established repository patterns.
- ▌ Dispatching Parallel Agents 2 · oleg494Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
- ▌ Git Workflow And Versioning 2 · oleg494 bundleStructures 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. Use when cutting a release, choosing a semantic version bump, tagging, or writing a changelog.
- ▌ Finishing A Development Branch 2 · oleg494Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
- ▌ Verification Before Completion 2 · oleg494Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
- ▌ Observability And Instrumentation 2 · oleg494Instruments code so production behavior is visible and diagnosable. Use when adding logging, metrics, tracing, or alerting. Use when shipping any feature that runs in production and you need evidence it works. Use when production issues are reported but you can't tell what happened from the available data.
- ▌ Yagni 2 · oleg494 bundleAlways-on. Law of minimalism: don't build what wasn't asked for. Abstraction must pay rent via present value or a genuine change-isolation boundary; hypothetical reuse → inline. New dependency → only if the pain is measurable. Dead code → delete. "For the future" → not a reason. Use for ANY code change.
- ▌ Dev Wiki 2 · oleg494 bundleAlways-on. Cross-chat memory (database, not conversation): record decisions, errors, patterns in the global Wiki (~/.memory). Use on "record"/"save"/"remember"/"запиши"/"сохрани"/"запомни"/"в память"/"память" or "what do we know about X"/"напомни". Hierarchy: portable → ~/.memory/Wiki/; project-specific → WORK/<project>/docs/. Cycle: file → index.md → log.md → python ~/.memory/db-tools/build.py → lint.
- ▌ Ponytail 2 · oleg494 bundleUse for coding tasks to minimize implementation weight without reducing requested behavior: reuse existing code, prefer stdlib/native, avoid speculative abstractions, fix root causes and verify the complete observable result.
- ▌ Fable Judge 2 · oleg494 bundleAdversarial verification of finished work: re-runs the claimed verifications, diffs what changed, detects false "done" claims, delivers an evidence-based verdict (VERIFIED / VERIFIED WITH CAVEATS / REFUTED). Use after any agent or model claims work is complete — "/fable-judge", "judge this work", "verify what it did". Also runs the fable-method trap suite via "/fable-judge suite <target>".
- ▌ Superpowers 2 · oleg494 bundleAlways-on development method: plan, check, implement, verify, report. Use for non-trivial tasks. Define observable acceptance before code, reproduce bugs before fixes, and complete the requested outcome without procedural permission gates.
- ▌ Fable Method 2 · oleg494 bundleA step-by-step problem-solving loop (classify the ask, define done, gather evidence, decide, act surgically, verify by observation, report outcome-first). Use when the user says "/fable-method", "use the fable method", or "approach this like Fable", or proactively when starting any multi-step task that no task-specific skill covers. Subcommands - plan (stop after the plan), audit (grade finished work against the loop), report (rewrite an answer outcome-first).
- ▌ Web Research 2 · oleg494Use when you need a fact from the outside world: "find out", "look up", "what do they say about", "how it works", "compare", "find information". Protocol: web search → primary sources → cross-check → answer with sources. Do not use for searching the knowledge base (business-wiki) or for facts already in the Wiki.
- ▌ Brainstorming 2 · oleg494Use before designing features, components, new subsystems, or behavior changes. Resolve intent, constraints, interfaces and acceptance before implementation; scale design depth to uncertainty without adding approval gates to authorized work.
- ▌ Design System 2 · oleg494Use when creating or refactoring a product UI system, shared components, themes, tokens, or dashboard styling. Keeps color, typography, spacing, states, and responsive rules coherent without introducing a large component abstraction prematurely.
- ▌ Writing Plans 2 · oleg494Use when you have a spec or requirements for a multi-step task, before touching code
- ▌ Autonomous Work 2 · oleg494 bundleUse when the user broadly authorizes autonomous work selection and continuation ("do useful work", "choose what is worth doing", "keep going without asking", "work autonomously", "работай сам", "делай что полезно", "продолжай без вопросов") — not for ordinary bounded requests, which keep their existing scope. Covers evidence-backed work selection, verify-then-continue loops, durable mission/progress/handoff state, immediate stop and revocation, and the optional foreground supervisor CLI. Never implies authorization for outward, destructive, or spending actions.
- ▌ Skill Authoring 2 · oleg494 bundleUse when creating or editing any skill: frontmatter rules (name/description), folder structure, script bundling, quality checklist — including converting the current session/procedure/URL into a new reusable skill ("learn", "/learn", "turn this session into a skill", "make a skill from this workflow", "сделай скилл из этой процедуры", "навык из"). Per the Agent Skills specification (Hermes-compatible).
- ▌ Dashboard Design 2 · oleg494Use when designing, redesigning, or reviewing marketplace, seller, operations, finance, logistics, or analytics dashboards: information hierarchy, KPIs, filters, charts, tables, honest data visualization, design tokens, responsive behavior, loading/empty/error states, and post-change UI verification in the running app. Not for posters, presentations, or static illustrations.
- ▌ Reasoning Engine 2 · oleg494Always-on evidence-first reasoning for non-trivial tasks: define the outcome, inspect authoritative sources, resolve material uncertainty, act within scope and verify. Scale analysis to consequences rather than fixed step or source counts.
- ▌ Code Graph Review 2 · oleg494Use BEFORE a commit or change review, when you need to understand "what this N-file change will break": blast radius over the diff, affected execution paths, dead code, architectural hubs/bridges, weak spots, rename with preview. Do not use for code search — CRG is for structural diff analysis, not navigation.
- ▌ Yagni · oleg494 bundleAlways-on. Law of minimalism: don't build what wasn't asked for. Abstraction must pay rent via present value or a genuine change-isolation boundary; hypothetical reuse → inline. New dependency → only if the pain is measurable. Dead code → delete. "For the future" → not a reason. Use for ANY code change.
- ▌ Superpowers · oleg494 bundleAlways-on development method: plan, check, implement, verify, report. Use for non-trivial tasks. Define observable acceptance before code, reproduce bugs before fixes, and complete the requested outcome without procedural permission gates.
- ▌ Reasoning Engine · oleg494Always-on evidence-first reasoning for non-trivial tasks: define the outcome, inspect authoritative sources, resolve material uncertainty, act within scope and verify. Scale analysis to consequences rather than fixed step or source counts.
- ▌ Engineering Persona · oleg494Always-on. Response format rules (not a persona): direct engineering tone, result first, evidence-based, no fluff, no "I would recommend". Code > words. Observation > assumption.
- ▌ Requesting Code Review · oleg494Use when completing tasks, implementing major features, or before merging to verify work meets requirements
- ▌ Debug Incident Protocol · oleg494Use when the user says: «it doesn't work», «still broken», «hung/stuck», «disappeared after the update», «it used to work», «the metric is zero but the UI is fine» — or when an incident needs to be analyzed, the root cause of a hang found, and whether a process was actually restarted verified. Covers: facts before theories (storage/logs/PID), symptom vs root cause, silent failure, restart ritual, localizing hangs with a progress marker, timeouts, cache masking. Do not use for writing tests (testing-discipline).
- ▌ Spec Driven Development · oleg494Creates 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. Use when a single requirement spans several independently testable capabilities.
- ▌ Test Driven Development · oleg494Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.
- ▌ Incremental Implementation · oleg494Delivers 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.
- ▌ Finishing A Development Branch · oleg494Use when implementation is complete, all tests pass, and you need to decide how to integrate the work