all publishers

oleg494

@oleg494 source repo

74 published skills

  1. ▌
    Dev Wiki · oleg494 bundle
    Use 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.
    3 repo stars
  2. ▌
    Ponytail · oleg494 bundle
    Use 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.
    3 repo stars
  3. ▌
    Fable Judge · oleg494 bundle
    Use 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).
    3 repo stars
  4. ▌
    Fable Method · oleg494 bundle
    Use 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.
    3 repo stars
  5. ▌
    Web Research · oleg494
    Use 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).
    3 repo stars
  6. ▌
    Brainstorming · oleg494 bundle
    Use 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).
    3 repo stars
  7. ▌
    Design System · oleg494 bundle
    Use 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.
    3 repo stars
  8. ▌
    Writing Plans · oleg494 bundle
    Use 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.
    3 repo stars
  9. ▌
    Autonomous Work · oleg494 bundle
    Use 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.
    3 repo stars
  10. ▌
    Skill Authoring · oleg494 bundle
    Use 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.
    3 repo stars
  11. ▌
    Dashboard Design · oleg494
    Use 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.
    3 repo stars
  12. ▌
    Code Graph Review · oleg494
    Use 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).
    3 repo stars
  13. ▌
    Money Path Safety · oleg494 bundle
    Use 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).
    3 repo stars
  14. ▌
    Testing Discipline · oleg494 bundle
    Use 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).
    3 repo stars
  15. ▌
    Windows Encoding Fixes · oleg494 bundle
    Use 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.
    3 repo stars
  16. ▌
    Architecture Simplicity · oleg494
    Use 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).
    3 repo stars
  17. ▌
    Code Review And Quality · oleg494 bundle
    Use 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).
    3 repo stars
  18. ▌
    Production First Decisions · oleg494
    Use 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.
    3 repo stars
  19. ▌
    Dispatching Parallel Agents · oleg494
    Use 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).
    3 repo stars
  20. ▌
    Git Workflow And Versioning · oleg494 bundle
    Use 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).
    3 repo stars
  21. ▌
    Verification Before Completion · oleg494 bundle
    Use 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).
    3 repo stars
  22. ▌
    Observability And Instrumentation · oleg494
    Use 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).
    3 repo stars
  23. ▌
    Shipping And Launch · oleg494
    Use 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).
    3 repo stars
  24. ▌
    Using Git Worktrees · oleg494
    Use 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).
    3 repo stars
  25. ▌
    Systematic Debugging · oleg494 bundle
    Use 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).
    3 repo stars
  26. ▌
    Receiving Code Review · oleg494
    Use 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.
    3 repo stars
  27. ▌
    Security And Hardening · oleg494 bundle
    Use 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).
    3 repo stars
  28. ▌
    Money Path Safety 2 · oleg494 bundle
    Use 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).
    3 repo stars
  29. ▌
    Testing Discipline 2 · oleg494 bundle
    Use 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.
    3 repo stars
  30. ▌
    Engineering Persona 2 · oleg494
    Always-on. Response format rules (not a persona): direct engineering tone, result first, evidence-based, no fluff, no "I would recommend". Code > words. Observation > assumption.
    3 repo stars
  31. ▌
    Shipping And Launch 2 · oleg494
    Prepares 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.
    3 repo stars
  32. ▌
    Using Git Worktrees 2 · oleg494
    Use 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
    3 repo stars
  33. ▌
    Systematic Debugging 2 · oleg494 bundle
    Use when encountering any bug, test failure, or unexpected behavior, before proposing fixes
    3 repo stars
  34. ▌
    Receiving Code Review 2 · oleg494
    Use 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
    3 repo stars
  35. ▌
    Requesting Code Review 2 · oleg494
    Use when completing tasks, implementing major features, or before merging to verify work meets requirements
    3 repo stars
  36. ▌
    Security And Hardening 2 · oleg494 bundle
    Hardens 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.
    3 repo stars
  37. ▌
    Windows Encoding Fixes 2 · oleg494 bundle
    Use 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.
    3 repo stars
  38. ▌
    Architecture Simplicity 2 · oleg494
    Use 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).
    3 repo stars
  39. ▌
    Code Review And Quality 2 · oleg494 bundle
    Conducts 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.
    3 repo stars
  40. ▌
    Debug Incident Protocol 2 · oleg494
    Use 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).
    3 repo stars
  41. ▌
    Spec Driven Development 2 · oleg494
    Creates 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.
    3 repo stars
  42. ▌
    Test Driven Development 2 · oleg494
    Drives 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.
    3 repo stars
  43. ▌
    Incremental Implementation 2 · oleg494
    Delivers 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.
    3 repo stars
  44. ▌
    Production First Decisions 2 · oleg494
    Use 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.
    3 repo stars
  45. ▌
    Dispatching Parallel Agents 2 · oleg494
    Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies
    3 repo stars
  46. ▌
    Git Workflow And Versioning 2 · oleg494 bundle
    Structures 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.
    3 repo stars
  47. ▌
    Finishing A Development Branch 2 · oleg494
    Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
    3 repo stars
  48. ▌
    Verification Before Completion 2 · oleg494
    Use 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
    3 repo stars
  49. ▌
    Observability And Instrumentation 2 · oleg494
    Instruments 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.
    3 repo stars
  50. ▌
    Yagni 2 · oleg494 bundle
    Always-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.
    3 repo stars
  51. ▌
    Dev Wiki 2 · oleg494 bundle
    Always-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.
    3 repo stars
  52. ▌
    Ponytail 2 · oleg494 bundle
    Use 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.
    3 repo stars
  53. ▌
    Fable Judge 2 · oleg494 bundle
    Adversarial 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>".
    3 repo stars
  54. ▌
    Superpowers 2 · oleg494 bundle
    Always-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.
    3 repo stars
  55. ▌
    Fable Method 2 · oleg494 bundle
    A 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).
    3 repo stars
  56. ▌
    Web Research 2 · oleg494
    Use 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.
    3 repo stars
  57. ▌
    Brainstorming 2 · oleg494
    Use 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.
    3 repo stars
  58. ▌
    Design System 2 · oleg494
    Use 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.
    3 repo stars
  59. ▌
    Writing Plans 2 · oleg494
    Use when you have a spec or requirements for a multi-step task, before touching code
    3 repo stars
  60. ▌
    Autonomous Work 2 · oleg494 bundle
    Use 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.
    3 repo stars
  61. ▌
    Skill Authoring 2 · oleg494 bundle
    Use 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).
    3 repo stars
  62. ▌
    Dashboard Design 2 · oleg494
    Use 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.
    3 repo stars
  63. ▌
    Reasoning Engine 2 · oleg494
    Always-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.
    3 repo stars
  64. ▌
    Code Graph Review 2 · oleg494
    Use 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.
    3 repo stars
  65. ▌
    Yagni · oleg494 bundle
    Always-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.
    3 repo stars
  66. ▌
    Superpowers · oleg494 bundle
    Always-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.
    3 repo stars
  67. ▌
    Reasoning Engine · oleg494
    Always-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.
    3 repo stars
  68. ▌
    Engineering Persona · oleg494
    Always-on. Response format rules (not a persona): direct engineering tone, result first, evidence-based, no fluff, no "I would recommend". Code > words. Observation > assumption.
    3 repo stars
  69. ▌
    Requesting Code Review · oleg494
    Use when completing tasks, implementing major features, or before merging to verify work meets requirements
    3 repo stars
  70. ▌
    Debug Incident Protocol · oleg494
    Use 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).
    3 repo stars
  71. ▌
    Spec Driven Development · oleg494
    Creates 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.
    3 repo stars
  72. ▌
    Test Driven Development · oleg494
    Drives 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.
    3 repo stars
  73. ▌
    Incremental Implementation · oleg494
    Delivers 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.
    3 repo stars
  74. ▌
    Finishing A Development Branch · oleg494
    Use when implementation is complete, all tests pass, and you need to decide how to integrate the work
    3 repo stars