[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7ADWWRRM30Y33ZTK41VCFVT":3,"skill-same:01M7ADWWRRM30Y33ZTK41VCFVT":43},{"skillNo":4,"name":5,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":15,"categories":16,"keywords":17,"publishedAt":18,"linkOnly":19,"markdownContent":20,"markdownBody":20,"frontMatter":21,"refName":22,"commitSha":23,"skillDirectory":24,"forksCount":25,"repositoryHtmlUrl":26,"repositoryHomepageUrl":6,"ownerHtmlUrl":27,"ownerBlogUrl":6,"ownerDescription":6,"updatedAt":28,"install":29,"resources":42},"01M7ADWWRRM30Y33ZTK41VCFVT","architecture",null,"zyadgfh\u002FZ-Syst","zyadgfh","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F315854134?v=4","01M7ADRHWJWRARA2DA2E44GC1Q","ZyadGamal","01M7ADRHXRHC9RZ6BKNHAVGK7C",0,"MIT","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002F.blackbox\u002Fskills\u002Farchitecture\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"# OBEY Clean Code by Robert C. Martin\n\nThis file defines mandatory working rules for this repository. Follow these instructions before making any code, test, refactor, review, or documentation change.\n\n## Priority and behavior\n\n- Treat every unqualified rule in this file as `MUST`; treat `Prefer` as `SHOULD`; treat `Do not`, `Avoid`, and `Never` as `MUST NOT` unless the user explicitly overrides it.\n- Prefer readability, maintainability, correctness, and safe change over cleverness or speed hacks.\n- Optimize for the next human reader.\n- When trade-offs exist, choose the option that reduces long-term complexity.\n- Never preserve bad structure just because it already exists.\n- Apply the Boy Scout Rule: leave touched code cleaner than you found it.\n\n## Core clean code principles\n\n- Write code primarily for humans, not just for execution.\n- Keep code simple, direct, and easy to modify.\n- Avoid accidental complexity.\n- Avoid surprising behavior.\n- Prefer explicit intent over implicit magic.\n- Prefer local reasoning: a reader should understand code with minimal jumping across files.\n- Reduce technical debt instead of moving it around.\n\n## Naming rules\n\n- Use intention-revealing names.\n- Names must explain purpose, role, or behavior without requiring extra comments.\n- Avoid misleading names, overloaded meanings, and visually confusable identifiers.\n- Make distinctions meaningful. Do not create names that differ only cosmetically.\n- Use pronounceable, searchable names.\n- Avoid abbreviations unless they are established domain or platform standards.\n- Avoid encodings in names, including type prefixes, implementation hints, and Hungarian notation.\n- Avoid unnecessary context in identifiers.\n- Add context through modules, classes, namespaces, or types when that is cleaner than longer names.\n- Use one word per concept across the codebase.\n- Do not use multiple synonyms for the same operation or concept.\n- Do not reuse a familiar word for a different meaning.\n- Class, type, and module names should be nouns or noun phrases.\n- Function and method names should be verbs or verb phrases.\n- Use problem-domain names for domain concepts.\n- Use solution-domain names for technical concepts.\n- Do not use cute, funny, cryptic, or private-joke names.\n\n## Function rules\n\n- Keep functions small.\n- Each function must do one thing.\n- A function should have one clear reason to change.\n- Keep each function at one level of abstraction.\n- Organize code top-down so readers see the high-level story before details.\n- Prefer descriptive names over short names.\n- Minimize the number of parameters.\n- Avoid boolean flag parameters. Split behavior into separate functions instead.\n- Avoid output parameters unless language conventions make them necessary.\n- Eliminate hidden side effects.\n- Separate commands from queries.\n- A function that answers a question should not also mutate state.\n- Prefer exceptions or explicit result types over ad hoc error codes, according to project language norms.\n- Isolate error handling from main logic.\n- Eliminate duplication aggressively.\n- Prefer straightforward control flow over clever control flow.\n- Refactor deep nesting into clearer structure.\n\n## Comment rules\n\n- Do not use comments to compensate for bad naming or bad structure.\n- First improve the code, then decide whether a comment is still needed.\n- Prefer self-explanatory code.\n- Use comments only when they add information the code cannot express well.\n- Good comment categories include:\n  - legal or licensing requirements\n  - non-obvious intent\n  - important warnings or constraints\n  - rationale for a surprising decision\n  - clarification of external behavior or protocol assumptions\n- Remove redundant, obsolete, obvious, noisy, and misleading comments.\n- Do not narrate the code line by line.\n- Keep comments precise and maintain them when code changes.\n- Avoid TODO comments unless they are actionable, specific, and necessary.\n\n## Formatting and structure\n\n- Use consistent formatting across the repository.\n- Format code to reveal structure and intent.\n- Keep related concepts close together.\n- Keep files, classes, and functions reasonably small.\n- Use vertical ordering to tell the story from higher level to lower level.\n- Use indentation to clarify scope, not to hide complexity.\n- Avoid excessive line length when it hurts readability.\n- Avoid decorative alignment that is brittle during edits.\n- Preserve a layout that supports fast scanning.\n\n## Objects, modules, and data structures\n\n- Separate behavior-rich objects from plain data carriers intentionally.\n- Do not mix data containers and business behavior arbitrarily.\n- Hide implementation details behind clear interfaces.\n- Expose behavior, not representation.\n- Use DTO-like structures as simple carriers when appropriate.\n- Avoid train-wreck call chains and unnecessary knowledge of internal structure.\n- Respect loose coupling and local boundaries.\n- Keep persistence, framework, and third-party details from obscuring business behavior or core logic.\n\n## Class and module design\n\n- Keep classes and modules small.\n- Each class or module should have one primary responsibility.\n- Favor high cohesion.\n- Split classes that accumulate unrelated behavior.\n- Organize code so likely changes remain local.\n- Public APIs should be small, obvious, and hard to misuse.\n- Prefer composition over complex inheritance unless inheritance is clearly the simpler and more stable model.\n- Keep constructors and setup logic from overwhelming domain behavior.\n\n## Error handling\n\n- Design error handling deliberately.\n- Keep the happy path easy to read.\n- Provide enough context in error messages for diagnosis.\n- Use error types or exception classes that support caller decisions.\n- Do not return `null` or equivalent absence sentinels when a safer model exists.\n- Do not pass `null` or equivalent invalid states unless the API explicitly models that case.\n- Prefer exceptions, special cases, empty objects, or explicit optionality according to the codebase's language and conventions.\n- Make resource cleanup and shutdown paths correct and visible.\n\n## Boundaries and external dependencies\n\n- Isolate third-party libraries behind local adapters or wrappers when practical.\n- Avoid coupling core logic directly to unstable external APIs.\n- Create narrow interfaces around dependencies.\n- Add learning tests or focused integration tests for tricky external behavior.\n- When a dependency does not exist yet, define interfaces from local needs, not from guesses about future implementations.\n\n## System construction rules\n\n- Separate constructing a system from using it.\n- Keep object graph assembly, dependency injection, factories, and framework bootstrapping out of ordinary business behavior.\n- Put startup wiring in an explicit main or composition area.\n- Use factories when construction policy is meaningful or complex.\n- Do not let cross-cutting concerns obscure ordinary code flow.\n- Use standards, frameworks, proxies, or AOP-style mechanisms only when they add demonstrable value.\n- Test-drive architectural decisions with executable slices, not only diagrams or configuration.\n- Use domain-specific languages only when they make system intent clearer than general-purpose code.\n\n## Tests\n\n- Treat tests as production-quality code.\n- Keep tests clean, readable, deterministic, and maintainable.\n- A test should communicate one main idea.\n- Prefer simple setup and clear assertions.\n- Avoid brittle tests coupled to irrelevant implementation details.\n- Tests should be fast when possible.\n- Tests should be isolated and order-independent.\n- Tests should be self-checking.\n- Add or update tests for behavior changes, bug fixes, and significant refactors.\n- Do not ship code changes without proportionate validation.\n- When fixing a bug, add a test that would have caught it, when feasible.\n\n## TDD and clean test rules\n\n- Prefer writing a failing test before production code when the behavior can be specified clearly.\n- Do not write production behavior beyond what a failing test or explicit requirement justifies.\n- Keep tests small enough that a failure names one behavior or one concept.\n- Prefer one assert or one conceptual assertion per test when that improves clarity.\n- Use test names and test data that reveal the business or technical behavior under test.\n- Build a small testing vocabulary or helper DSL when repeated setup hides intent.\n- Keep test code clean; dirty tests reduce the ability to change production code safely.\n- Avoid tests that require multiple manual steps to run.\n- Use coverage patterns to find untested risk, not as a substitute for meaningful assertions.\n- Treat ignored, flaky, or skipped tests as unresolved questions.\n\n## Concurrency and async work\n\n- Do not introduce concurrency unless it provides a real benefit.\n- Prefer simpler sequential code when it is sufficient.\n- Minimize shared mutable state.\n- Prefer immutability, message passing, or clear ownership boundaries.\n- Keep synchronized or locked sections as small as possible.\n- Be explicit about shutdown, cancellation, timeouts, and cleanup.\n- Test concurrent behavior carefully where it matters.\n- Know the execution model before changing concurrent code.\n- Avoid dependencies between synchronized methods.\n- Get non-concurrent behavior correct before adding threading.\n- Make threaded code pluggable and tunable when its policy or concurrency level may vary.\n- Run concurrency-sensitive tests under varied thread counts, schedules, and platforms where practical.\n- Treat spurious failures as possible concurrency defects until evidence says otherwise.\n\n## Refactoring rules\n\n- Refactor in small, safe steps.\n- Preserve behavior while improving structure.\n- First make it work, then make it right.\n- Remove duplication, dead code, misleading abstractions, and special-case clutter.\n- Rename aggressively when names are weak.\n- Extract code when doing so improves cohesion and clarity.\n- Inline abstractions that no longer earn their cost.\n- Prefer the simplest design that passes all relevant tests.\n\n## Emergent design and successive refinement\n\n- Prefer designs that run all relevant tests, remove duplication, express intent, and use the fewest necessary classes and methods.\n- Refine code through working drafts rather than expecting the first version to be clean.\n- When code starts rough, keep improving names, structure, and tests until intent is clear.\n- Do not start a grand redesign when incremental refinement can recover the design safely.\n- Use the Boy Scout Rule on touched code, but keep cleanup proportional to the task.\n\n## Smells to detect and eliminate\n\nActively look for and fix these issues when touching code:\n\n- vague or misleading names\n- duplicated logic\n- oversized functions\n- oversized classes or modules\n- mixed abstraction levels\n- hidden side effects\n- boolean control flags\n- long parameter lists\n- deep nesting\n- excessive conditionals that should be isolated or polymorphic\n- comment-heavy code that should be refactored instead\n- dead code and unused abstractions\n- fragile tests\n- environment-dependent tests without need\n- unnecessary indirection\n- accidental complexity\n- coupling that spreads change broadly\n- build or tests requiring more than one manual step\n- code at the wrong level of abstraction\n- base classes depending on derivatives\n- transitive navigation through object internals\n- artificial coupling between unrelated concepts\n- hidden logical dependencies\n- unimplemented obvious behavior\n- incorrect boundary behavior\n- overridden safeties\n- magic numbers without named meaning\n- negative conditionals that obscure intent\n- ignored tests and insufficient boundary tests\n- functions that require readers to understand an algorithm before they can trust the name\n\n## Change Process\n\nFor every non-trivial task:\n\n1. Understand the intent and affected behavior.\n2. Identify the simplest correct change.\n3. Improve names before adding comments.\n4. Keep edits localized when possible.\n5. Add or update tests as needed.\n6. Run relevant validation.\n7. Review the diff for readability, duplication, and unnecessary complexity.\n8. Ensure the final code is cleaner than before.\n\n## Implementation preferences\n\n- Prefer explicit, boring, maintainable solutions.\n- Prefer standard library and existing project patterns over new dependencies.\n- Do not add a dependency unless it clearly reduces overall complexity.\n- Reuse established project conventions unless they conflict with these rules or the user explicitly asks otherwise.\n- Keep interfaces small.\n- Keep state transitions obvious.\n- Avoid premature optimization.\n- Optimize only when there is evidence or a known requirement.\n\n## Review checklist\n\nBefore finishing, verify all of the following:\n\n- Names reveal intent.\n- Functions are small and focused.\n- Classes and modules have clear responsibilities.\n- Comments are necessary and accurate.\n- Error handling is explicit and useful.\n- Duplication was removed where reasonable.\n- Tests cover the changed behavior appropriately.\n- The code reads cleanly from top to bottom.\n- The design is simpler or at least not more complex than before.\n- The change follows existing project conventions.\n\n## Output Expectations\n\nWhen making changes:\n\n- Briefly explain what changed.\n- State what tests or checks were run.\n- Call out any unresolved risk, assumption, or trade-off.\n- If a requested change conflicts with these rules, follow the user request but mention the conflict explicitly.\n\n## Hard rules\n\n- Do not introduce misleading names.\n- Do not keep duplicated logic without a strong reason.\n- Do not add comments where better code would remove the need.\n- Do not mix querying with mutation without a strong reason.\n- Do not silently broaden scope beyond the requested task.\n- Do not leave touched code less readable than before.\n\nand\n\n# OBEY Code Complete by Steve McConnell\n\n## Purpose\n\nThis repository follows **Code Complete** in the sense of Steve McConnell:\napply disciplined software construction practices that reduce defects, improve readability, and produce robust code under real-world constraints.\n\nAll code generation, edits, and reviews must optimize for:\n- low-defect construction\n- readable and intention-revealing code\n- controlled complexity\n- defensive programming where appropriate\n- strong routine and class design\n- practical correctness over style theater\n\nThis file is a binding engineering policy: `MUST` is binding, `SHOULD` is a strong default, and `MUST NOT` is forbidden.\n\n---\n\n## Primary Directive\n\nConstruction quality is not accidental.\n\nWhen uncertain, choose the option that:\n1. lowers defect probability\n2. makes the code easier to inspect and reason about\n3. reduces control-flow complexity\n4. uses data and routines clearly\n5. protects the program against invalid states and misuse\n\nDo not optimize for cleverness, minimal keystrokes, or fashionable idioms at the cost of clarity.\n\n---\n\n## Foundational Construction Rules\n\n1. Write code primarily for human readers.\n2. Favor clarity, locality, and explicitness over trickiness.\n3. Keep control flow simple and visible.\n4. Make correctness easier to achieve than incorrectness.\n5. Use conventions consistently.\n\n---\n\n## Construction Prerequisites and Decisions\n\n1. Do not treat construction as isolated typing; verify that requirements, architecture, major risks, and coding conventions are clear enough for the change.\n2. Resolve major construction decisions before large implementation work: language constraints, error policy, data representation, reuse strategy, integration approach, and testing approach.\n3. Use upstream uncertainty as a reason to build a small validated slice, not as an excuse for speculative code.\n4. Keep the software metaphor or design model only if it helps make concrete construction decisions.\n5. Measure twice before cutting when an early decision will be expensive to reverse.\n\n---\n\n## Pseudocode Programming Process\n\n1. For complex routines, sketch the routine in precise pseudocode or comments before filling in details.\n2. Refine pseudocode until it names the real steps at a consistent abstraction level.\n3. Convert clear pseudocode into code and keep only comments that still add intent, constraints, or rationale.\n4. Do not use pseudocode as a substitute for understanding the algorithm.\n\n---\n\n## Routine Design Rules\n\n1. Routines should have one clear purpose.\n2. The routine name should describe the result or action precisely.\n3. Keep the interface as small as practical.\n4. Avoid long parameter lists and flag arguments.\n5. Separate setup, validation, computation, and side effects when they are conceptually different.\n6. Return values should be meaningful and hard to misuse.\n7. Prefer guard clauses and straightforward structure over deeply nested logic.\n\nAnti-patterns (MUST NOT):\n- routines that do several unrelated things\n- routines whose names describe implementation detail instead of purpose\n- many hidden side effects\n- boolean parameters that switch routine mode\n\n---\n\n## Variable and Data Rules\n\n1. Use names that reveal purpose and meaning.\n2. Keep variable scope as small as practical.\n3. Initialize variables deliberately.\n4. Prefer named constants or stable values where a variable is not meant to change.\n5. Avoid magic numbers and unexplained sentinel values.\n6. Use stronger data types when primitives hide meaning.\n\nAnti-patterns (MUST NOT):\n- reused loop\u002Findex\u002Ftemp variables beyond their purpose\n- long-lived mutable locals carrying many meanings\n- values whose units or semantics are unclear\n\n---\n\n## Data Type Rules\n\n1. Choose data types that make invalid or ambiguous values harder to represent.\n2. Name constants for magic values, units, bounds, and sentinel meanings.\n3. Use booleans only for true binary meanings; replace flag fields with clearer states when needed.\n4. Use enumerations or named alternatives when a value belongs to a closed set.\n5. Use arrays, records, maps, and tables only where their shape communicates the data meaning.\n6. Encapsulate unusual data structures behind routines or types that reveal purpose.\n7. Keep units, ranges, precision, encoding, and ownership visible near the data they affect.\n\n---\n\n## Control Flow Rules\n\n1. Prefer the simplest control flow that expresses the logic.\n2. Keep nesting shallow when possible.\n3. Replace complicated boolean logic with named predicates or clearer structure.\n4. Use case\u002Fswitch constructs only when they improve clarity.\n5. Eliminate impossible paths and dead branches.\n6. Avoid surprising exits unless they clarify the routine.\n\nAnti-patterns (MUST NOT):\n- deeply nested conditionals\n- complicated loop exits with hidden state changes\n- control flow dependent on side effects in expressions\n- clever one-liners that obscure the logic\n\n---\n\n## Statement, Conditional, and Loop Rules\n\n1. Organize straight-line code so dependencies appear before use and related statements stay together.\n2. Keep conditionals positive and direct when possible.\n3. Put the normal path where readers can find it quickly.\n4. Use loops with clear initialization, termination, and update rules.\n5. Keep loop bodies focused; extract work when a loop hides several responsibilities.\n6. Avoid unusual control structures unless they are clearer than ordinary alternatives.\n7. Use table-driven methods when repeated branching is stable and the table can be validated.\n\n---\n\n## Defensive Programming Rules\n\n1. Validate inputs at trust boundaries.\n2. Use assertions or invariant checks where programmer assumptions matter.\n3. Distinguish between recoverable conditions and programming errors.\n4. Fail in a way that preserves diagnosability.\n5. Do not silently continue from corrupted or impossible state.\n\nAnti-patterns (MUST NOT):\n- assuming all callers are correct\n- burying invalid state until it causes distant failures\n- swallowing exceptions without context\n\n---\n\n## Error Handling Rules\n\n1. Handle errors at the right level of abstraction.\n2. Preserve useful context.\n3. Do not let error handling dominate the normal path.\n4. Standardize similar failure handling.\n5. Prefer explicit, well-understood failure semantics over ad hoc conventions.\n\n---\n\n## Table-Driven and Data-Driven Rules\n\n1. Prefer data-driven logic over long repeated condition chains when the mapping is stable and explicit.\n2. Use tables or maps for configuration-like decisions.\n3. Keep the structure obvious and validated.\n4. Do not hide complex logic in inscrutable data encodings.\n\n---\n\n## Class and Module Design Rules\n\n1. Each class or module should own a focused responsibility.\n2. Separate interface from implementation.\n3. Hide representation and incidental detail.\n4. Keep classes cohesive.\n5. Reduce coupling through clear contracts and limited knowledge of internals.\n\nAnti-patterns (MUST NOT):\n- god classes\n- modules with mixed persistence, formatting, business logic, and integration concerns\n- public surfaces that expose internal bookkeeping\n\n---\n\n## Complexity Management Rules\n\n1. Treat rising complexity as a defect risk.\n2. Prefer simple code over clever code.\n3. Break apart large or tangled routines and modules.\n4. Remove duplication that multiplies maintenance effort.\n5. Choose designs that reduce the amount a maintainer must keep in working memory.\n\n---\n\n## Construction with Preconditions and Postconditions\n\n1. Be explicit about routine assumptions.\n2. Encode important invariants close to the code they protect.\n3. Keep contracts simple and testable.\n4. Use assertions for programmer mistakes, validation for external input, and domain errors for expected business failures.\n\n---\n\n## Comment Rules\n\n1. Comments should explain intent, rationale, contracts, and non-obvious facts.\n2. Do not comment obvious code instead of improving it.\n3. Keep comments accurate or delete them.\n4. Prefer self-documenting structure first, comments second.\n\n---\n\n## Coding Standards Rules\n\n1. Be consistent within the codebase.\n2. Use formatting, naming, and file structure to support readability.\n3. Standardize common idioms so readers do not need to relearn style per module.\n4. Prefer a shared convention over local personal taste.\n\n---\n\n## Incremental Construction Rules\n\n1. Build in small, verifiable increments.\n2. Integrate frequently enough to surface conflicts and misunderstanding early.\n3. Keep partial work from rotting in long-lived isolation.\n4. Review and improve code as part of construction, not only after it.\n\n---\n\n## Quality, Collaboration, Debugging, and Refactoring\n\n1. Use reviews, inspections, pair work, tests, and static checks according to the risk of the code.\n2. Treat debugging as diagnosis: reproduce, isolate, explain, fix, and verify rather than guessing.\n3. Fix the root cause when practical, not only the symptom.\n4. Add tests around defects so the same failure is easier to detect next time.\n5. Refactor when structure hides intent, duplicates knowledge, or raises defect probability.\n6. Keep refactoring separate from behavior changes when that improves reviewability.\n\n---\n\n## Performance, Integration, Tools, and Craftsmanship\n\n1. Do not tune performance until the requirement and evidence justify it.\n2. When tuning is justified, measure before and after, and keep clarity unless the tradeoff is explicit.\n3. Integrate frequently enough to expose construction conflicts early.\n4. Use programming tools, scripts, debuggers, profilers, editors, and build automation to reduce error-prone manual work.\n5. Keep layout and style consistent enough that readers can focus on meaning.\n6. Prefer self-documenting code, but add documentation where the code cannot express intent, constraints, or usage.\n7. Treat personal discipline, curiosity, and ability to withstand careful review as part of construction quality.\n\n---\n\n## Review Rules\n\nWhen reviewing code, actively look for:\n- unclear names\n- weak routine boundaries\n- long parameter lists\n- unnecessary nesting\n- hidden side effects\n- poor defensive checks at trust boundaries\n- duplicated logic\n- confusing control flow\n- god classes or mixed responsibilities\n- comments compensating for poor structure\n\n---\n\n## Forbidden Patterns\n\n### Cleverness over Clarity\n- dense tricks that are hard to inspect\n- compressed expressions that save lines but increase interpretation cost\n\n### Routine Bloat\n- one routine doing several phases and concerns\n- long signatures with many unrelated parameters\n\n### Defensive Vacuum\n- no validation at trust boundaries\n- no checks around critical assumptions\n- silent fallback from impossible state\n\n### Comment-as-Crutch\n- obvious comments over bad code\n- stale comments that mislead\n\n### Consistency Neglect\n- arbitrary naming and formatting changes\n- module-specific mini dialects inside one codebase\n\n---\n\n## Code Generation Rules\n\nWhen generating code, default to:\n1. clear names\n2. focused routines\n3. explicit data meaning\n4. simple control flow\n5. defensive checks at boundaries\n6. cohesive classes\u002Fmodules\n7. consistent style\n\nAvoid by default:\n- dense clever code\n- broad god objects\n- fragile hidden assumptions\n- unnecessary complexity in loops and conditionals\n- comments where better names or decomposition would do\n\n---\n\n## Testing Rules\n\n1. Test routine behavior around normal, boundary, and invalid inputs.\n2. Test defensive checks where boundary validation matters.\n3. Keep tests aligned with routine contracts.\n4. Test complex data-driven logic with representative tables and edge cases.\n\n---\n\n## Review Checklist\n\nBefore finalizing any change, verify:\n- Are names clear and intention-revealing?\n- Are routines focused and reasonably small?\n- Is control flow straightforward?\n- Are trust boundaries defended?\n- Are contracts and invariants explicit enough?\n- Did we reduce or at least not increase complexity?\n- Are classes\u002Fmodules cohesive?\n- Did we avoid cleverness that harms inspection?\n- Are comments used only where they add value?\n- Is the style consistent with the rest of the codebase?\n\nIf any answer is no, revise before shipping.\n\n---\n\n## Final Instruction\n\nWhen uncertain, choose the option that:\n1. lowers defect risk\n2. improves readability\n3. simplifies control flow\n4. strengthens defensive correctness\n5. keeps the code easier to inspect and maintain\n\nWrite code that would stand up to careful review.\n\n\n# OBEY The Pragmatic Programmer by Andrew Hunt and David Thomas\n\n## Purpose\n\nThis repository follows **The Pragmatic Programmer** in the sense of Andrew Hunt and David Thomas:\nwork pragmatically, take responsibility for quality, automate what is repetitive, and keep code and process adaptable.\n\nAll code generation, edits, and reviews must optimize for:\n- clear ownership and responsibility\n- avoiding duplicated knowledge\n- orthogonality\n- incremental delivery\n- ruthless feedback\n- automation of repetitive work\n- code that is easy to change and easy to reason about\n\nThis file is a binding engineering policy: `MUST` is binding, `SHOULD` is a strong default, and `MUST NOT` is forbidden.\n\n---\n\n## Primary Directive\n\nBe pragmatic, not dogmatic.\n\nWhen uncertain, choose the option that:\n1. reduces knowledge duplication\n2. keeps concerns independent\n3. shortens feedback loops\n4. leaves the system easier to change\n5. makes intent clearer to future maintainers\n\nDo not follow style or process rituals that do not improve outcomes.\n\n---\n\n## Core Pragmatic Principles\n\n### Own the Result\n1. Take responsibility for the quality and changeability of the code you touch.\n2. Do not blame tooling, framework defaults, or “existing style” for avoidable bad design.\n3. Surface trade-offs, risks, and uncertainty explicitly.\n\n### Think Beyond the Local Edit\n1. Every change affects future maintainability.\n2. Small quick fixes that multiply future cost are usually a bad bargain.\n3. Leave the area better than you found it.\n\n### Favor Adaptability\n1. Build systems that are easy to observe, test, and change.\n2. Prefer flexible boundaries over brittle cleverness.\n3. Avoid premature commitment when requirements are still moving.\n\n### Named Pragmatic Habits\n1. Treat quality as a requirement to negotiate with users and sponsors, not as an abstract pursuit of perfection.\n2. Stop polishing when the software is good enough for its real users and risks.\n3. Keep a knowledge portfolio: invest in learning, diversify skills, and revisit stale assumptions.\n4. Communicate decisions, risks, and tradeoffs clearly enough that others can act on them.\n5. Watch for entropy and small broken windows before they become normal.\n6. Use Stone Soup tactics only to create real progress, not to hide missing agreement.\n7. Watch for boiled-frog drift where gradual degradation becomes invisible.\n\n---\n\n## DRY Rules\n\nDRY means **do not duplicate knowledge**, not merely do not duplicate text.\n\n1. A business rule should have one authoritative representation.\n2. Validation logic for the same concept should not be scattered.\n3. Status semantics, mappings, and calculations should not be copied across layers.\n4. Configuration and schema meaning should not be repeated inconsistently.\n5. Avoid duplicated process steps that can be automated.\n\nAnti-patterns (MUST NOT):\n- the same rule encoded in UI, API, service, and DB trigger with no ownership\n- copy\u002Fpaste with minor edits for “just this one case”\n- duplicated manual deployment or testing steps\n- one concept with multiple partially aligned implementations\n\n---\n\n## Orthogonality Rules\n\n1. Keep components independent so one change does not force unrelated changes elsewhere.\n2. Minimize hidden couplings through globals, ambient context, or shared mutable state.\n3. Avoid overlapping responsibilities between modules.\n4. Separate policy from mechanism, data from presentation, orchestration from computation.\n\nAnti-patterns (MUST NOT):\n- one change requiring edits in many unrelated places\n- one module knowing too much about internal details of others\n- shared utility modules creating sideways coupling everywhere\n\n---\n\n## Tracer Bullets and Iterative Delivery\n\n1. Prefer a thin end-to-end slice over a pile of isolated pieces.\n2. Use tracer bullets to validate architecture, integration, and assumptions early.\n3. Keep the first slice simple but real enough to prove the path.\n4. Refine from working feedback instead of predicting everything up front.\n\nAnti-patterns (MUST NOT):\n- building many layers before anything runs end to end\n- treating prototypes as production without hardening\n- waiting for perfect certainty before integrating\n\n---\n\n## Reversibility, Domain Languages, and Requirements\n\n1. Preserve reversibility when requirements, vendors, platforms, databases, or deployment environments may change.\n2. Avoid irreversible commitments until evidence makes them worth the cost.\n3. Use a small domain language when it expresses domain rules more directly than general-purpose code.\n4. Keep domain languages readable by the people who must validate or change them.\n5. Dig for real requirements; do not accept current implementation details as requirements.\n6. Do not fall into the specification trap where prose keeps growing but uncertainty does not fall.\n7. Start building a working slice when further specification no longer reduces meaningful risk.\n8. Respect informed hesitation: if the team is not ready, identify the missing information or feedback.\n\n---\n\n## Prototyping Rules\n\n1. Use prototypes to learn, not to pretend you are done.\n2. Be explicit about what a prototype proves and what it does not.\n3. Do not let experimental shortcuts silently become production defaults.\n4. Carry forward only the lessons or code that still deserve to survive.\n\n---\n\n## Automation Rules\n\n1. Automate repetitive, error-prone, or easy-to-forget tasks.\n2. Prefer repeatable scripts over tribal-knowledge commands.\n3. Build, test, lint, format, package, and deploy steps should be reproducible.\n4. Keep local automation aligned with the project's shared build, test, and release automation.\n\nAnti-patterns (MUST NOT):\n- “works on my machine” build steps\n- manual release rituals with many hidden prerequisites\n- documentation that describes what a script should do instead of having the script\n\n---\n\n## Feedback Loop Rules\n\n1. Shorten the time between change and feedback.\n2. Run relevant tests early and often.\n3. Use automated checks where they reduce real risk.\n4. Make failure visible fast.\n5. Prefer a cheap early signal over a late expensive surprise.\n\n---\n\n## Design by Contract and Assertions\n\n1. Make assumptions explicit in code.\n2. Use assertions or invariant checks where they clarify impossible states.\n3. Distinguish between programmer errors, contract violations, and expected domain failures.\n4. Keep contracts close to the abstraction they protect.\n\nAnti-patterns (MUST NOT):\n- relying on comments for critical preconditions\n- hiding invariant assumptions in scattered callers\n- returning nonsense values for impossible states\n\n---\n\n## Error Handling and Recovery\n\n1. Detect errors close to their source.\n2. Do not discard useful error context.\n3. Let callers distinguish retryable, recoverable, and permanent failures where relevant.\n4. Fail loudly enough to diagnose, but with boundaries that prevent system-wide collapse.\n\n---\n\n## Naming and Communication Rules\n\n1. Code is communication first.\n2. Use names that reflect domain meaning and developer intent.\n3. Prefer clarity over cleverness.\n4. Write comments or docs where they convey decision rationale, contracts, or non-obvious behavior.\n5. Writing is part of engineering, not overhead.\n\n---\n\n## Text and Data Rules\n\n1. Favor plain text and open formats for long-lived automation and integration where practical.\n2. Make scripts and configs inspectable and diffable.\n3. Keep serialization and config formats explicit and version-aware.\n4. Avoid opaque binary or framework-specific lock-in unless justified.\n\n---\n\n## State and Concurrency Rules\n\n1. Treat shared mutable state as expensive.\n2. Prefer immutability, isolation, or explicit synchronization when state is shared.\n3. Keep concurrency assumptions visible.\n4. Do not add asynchronous complexity unless it clearly earns its cost.\n\n---\n\n## Estimation and Increment Rules\n\n1. Break work into pieces that can be reasoned about, tested, and corrected.\n2. Keep plans and estimates honest about uncertainty.\n3. Prefer small deliverable increments to large hidden progress.\n4. Make risk visible early.\n\n---\n\n## Tooling Rules\n\n1. Know and use the tools that amplify correctness and speed.\n2. Do not hand-do tasks that should be scripted.\n3. Keep editor, formatter, lint, tests, and local scripts aligned with team standards.\n4. Improve the toolchain when repeated friction appears.\n\n### Basic Tool Rules\n- Use source control for every meaningful project, including small or solo work.\n- Prefer inspectable plain text for long-lived scripts, configs, data, and generated sources when practical.\n- Use shell tools for exploration, automation, and repeatable transformations where they fit.\n- Use editor capabilities to reduce repetitive manual edits.\n- Use text manipulation languages or scripts for systematic changes that would be error-prone by hand.\n- Use code generators to remove duplicated mechanical work, but keep the source specification authoritative.\n- When debugging, do not guess: reproduce, observe, isolate, explain, fix, and verify.\n- Do not rely on generated code, tools, specifications, or formal methods you do not understand.\n\n---\n\n## Resource and Coupling Rules\n\n1. Finish what you start when allocating, opening, locking, or otherwise acquiring resources.\n2. Release every resource you acquire, preferably in the opposite order from acquisition.\n3. Keep resource ownership local and explicit.\n4. Apply shy-code and Law of Demeter discipline so modules reveal only necessary information.\n5. Avoid temporal coupling; make ordering requirements explicit or remove them.\n6. Use metaprogramming only when it reduces duplication or improves adaptability without hiding behavior.\n7. Use blackboard-style coordination only when uncertain order, multiple sources, or opportunistic collaboration justify it.\n8. Understand algorithmic growth before writing or accepting performance-sensitive code.\n\n---\n\n## Project and Team Rules\n\n1. Build pragmatic teams around shared responsibility, automation, fast feedback, and visible quality.\n2. Test unit behavior, integration, validation and verification, resource exhaustion, errors and recovery, performance, usability, and tests themselves where relevant.\n3. Treat writing as engineering work: docs, comments, commit messages, scripts, and tests must communicate intent.\n4. Set expectations explicitly with users and stakeholders.\n5. Take pride in code, tests, documentation, and generated artifacts.\n6. Be skeptical of methods, diagrams, and ceremonies that do not improve the work.\n\n---\n\n## Broken Windows Rule\n\n1. Do not normalize local decay.\n2. Fix small quality problems before they signal that nobody cares.\n3. Tidy the code you touch where the cost is low and the value is immediate.\n4. Avoid leaving behind “temporary” hacks with no cleanup plan.\n\n---\n\n## Review Rules\n\nWhen reviewing code, actively look for:\n- duplicated knowledge, not just duplicated lines\n- hidden couplings\n- missing automation opportunities\n- long feedback loops\n- local fixes that worsen future changeability\n- unclear contracts or assumptions\n- non-repeatable manual processes\n- brittle integration points\n- code that communicates poorly\n\n---\n\n## Forbidden Patterns\n\n### Cargo-Cult Process\n- rituals followed with no benefit\n- documentation and checklists replacing automation\n\n### Knowledge Duplication\n- same rule in many places\n- copied logic because “layers need it too”\n\n### Non-Orthogonal Design\n- modules with overlapping responsibilities\n- changes leaking across boundaries by default\n\n### Manual Everything\n- repeated human steps for build, test, release, setup, or validation\n- hidden local environment assumptions\n\n### Prototype Fossilization\n- experimental code promoted to production without redesign or hardening\n\n---\n\n## Code Generation Rules\n\nWhen generating code, default to:\n1. one clear source of truth for each rule\n2. orthogonal responsibilities\n3. fast local feedback\n4. automation over repeated manual work\n5. explicit contracts and assumptions\n6. readable names and communication\n7. incremental end-to-end slices when building new capabilities\n\nAvoid by default:\n- copy\u002Fpaste rule duplication\n- tangled modules\n- fragile manual workflows\n- overcommitting to an architecture before the first end-to-end path works\n\n---\n\n## Testing Rules\n\n1. Keep tests runnable quickly and often.\n2. Prefer tests that align with the business or technical contract being protected.\n3. Use automation so validation is habitual, not heroic.\n4. Keep flaky or environment-dependent tests out of the critical feedback path where possible.\n\n---\n\n## Review Checklist\n\nBefore finalizing any change, verify:\n- Did we reduce duplicated knowledge?\n- Are responsibilities more orthogonal after the change?\n- Did we improve or preserve fast feedback?\n- Did we automate anything repetitive that was hurting reliability?\n- Are contracts and assumptions clearer?\n- Is the code easier to communicate about?\n- Did we avoid prototype shortcuts becoming silent production defaults?\n- Did we fix at least one small “broken window” if it was in the touched area?\n\nIf any answer is no, revise before shipping.\n\n---\n\n## Final Instruction\n\nWhen uncertain, choose the option that:\n1. removes duplicated knowledge\n2. keeps concerns orthogonal\n3. shortens feedback loops\n4. improves automation\n5. leaves the codebase easier to change tomorrow\n\nBe pragmatic, and make the right thing the easy thing.\n\n---\n\n# OBEY Clean Code by Robert C. Martin",{},"main","f4a94d0fb721a5e4f4f937d814f0a296a9e35565",".blackbox\u002Fskills\u002Farchitecture",1,"https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst","https:\u002F\u002Fgithub.com\u002Fzyadgfh","2026-11-15 00:23:38",{"source":7,"skillName":5,"commands":30,"prompt":40,"zipAvailable":41},[31,34,37],{"tool":32,"command":33},"npx","npx skills add zyadgfh\u002FZ-Syst --skill architecture",{"tool":35,"command":36},"bunx","bunx skills add zyadgfh\u002FZ-Syst --skill architecture",{"tool":38,"command":39},"pnpm","pnpm dlx skills add zyadgfh\u002FZ-Syst --skill architecture","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002F.blackbox\u002Fskills\u002Farchitecture\u002FSKILL.md",true,[],[44,51,58,66,73,80],{"skillNo":45,"name":46,"nameZh":6,"description":47,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":48,"categories":49,"keywords":50,"publishedAt":18},"01M7ADYDYBCSZFRC5ZBQCZC9Z0","supabase","Use when doing ANY task involving Supabase. Triggers: Supabase products (Database, Auth, Edge Functions, Realtime, Storage, Vectors, Cron, Queues); client libraries and SSR integrations (supabase-js, @supabase\u002Fssr) in Next.js, React, SvelteKit, Astro, Remix; auth issues (login, logout, sessions, JWT, cookies, getSession, getUser, getClaims, RLS); Supabase CLI or MCP server; schema changes, migrations, declarative schemas, security audits, Postgres extensions (pg_graphql, pg_cron, pg_vector); debugging and troubleshooting errors or unexpected behavior on Supabase projects (HTTP errors, Postgres errors, RLS surprises, permission denied, schema cache issues, timeouts, Edge Function crashes, Realtime drops, Storage failures) and reading or querying logs (Logs Explorer, ClickHouse).","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002Fagent\u002Fskills\u002Fsupabase\u002FSKILL.md",[],[],{"skillNo":52,"name":53,"nameZh":6,"description":54,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":55,"categories":56,"keywords":57,"publishedAt":18},"01M7ADY1YMGRXW9GZYC4TS4NGY","supabase-postgres-best-practices","Postgres best practices maintained by Supabase, for Postgres running anywhere. Load this skill BEFORE writing or changing anything that lives in a Postgres database: creating or altering tables and columns (including choosing column types), schema design, migrations and declarative schema files, RLS policies and the tests that verify them, indexes, triggers, database functions, queues and scheduled jobs (pg_cron, pgmq), vector\u002Fsemantic search (pgvector), and restoring dumps (pg_restore) or importing data. Also load it when diagnosing slow queries, high CPU, timeouts, EXPLAIN plans, connection exhaustion, locking, bloat, or rows visible to the wrong user or tenant. This is not just a performance guide — schema, migration, security, and SQL authoring tasks need these rules too, even for a one-column change or a single query.","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002Fagent\u002Fskills\u002Fsupabase-postgres-best-practices\u002FSKILL.md",[],[],{"skillNo":59,"name":60,"nameZh":6,"description":61,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":62,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":18},"01M7ADXNAA4JTVTNRV7EHJX2W4","backend-patterns","Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002FLICENSE","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":18},"01M7ADXBNGSAKY4TXH96Y5MCMF","code-vulnscan","Use this when the user wants to find security vulnerabilities in a codebase, perform a security audit, scan for CVEs, detect secrets, review React\u002FNext.js or Go services, audit architecture\u002Fapplication\u002Finfrastructure flaws, review auth\u002FAPI\u002Fcrypto\u002Fbusiness logic, check IaC\u002Fcloud\u002Fruntime configs, or generate a vulnerability report. Performs taint-flow, control-flow, architecture, and exploitability analysis across Python, JS\u002FTS, Java, Go, PHP, Ruby, C\u002FC++, C#, Rust, and infrastructure.","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002F.github\u002Fskills\u002Fcode-vulnscan\u002FSKILL.md",[],[],{"skillNo":74,"name":75,"nameZh":6,"description":76,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":77,"categories":78,"keywords":79,"publishedAt":18},"01M7ADX5Q4HEA774P07HFJZVYD","z-syst-pharmacy","Z-Syst Pharmacy Management System - Comprehensive rules for building a professional pharmacy management system using Laravel. Covers products, stock, purchases, sales, invoices, prescriptions, finance, reports, and SaaS expansion. Follow strict engineering principles: clean architecture, service layer pattern, database-first design, and audit-trail tracking.","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002F.blackbox\u002Fskills\u002Fz-syst-pharmacy\u002FSKILL.md",[],[],{"skillNo":81,"name":82,"nameZh":6,"description":83,"descriptionZh":6,"repositoryFullName":7,"ownerLogin":8,"ownerAvatarUrl":9,"ownerAccountNo":10,"ownerDisplayName":11,"repositoryNo":12,"starsCount":13,"licenseSpdxId":14,"licenseFileUrl":6,"sourceHtmlUrl":84,"categories":85,"keywords":86,"publishedAt":18},"01M7ADX30C4C1T49R63PVH35MZ","ui-ux-promax","Brief description of what this Skill does and when to use it","https:\u002F\u002Fgithub.com\u002Fzyadgfh\u002FZ-Syst\u002Fblob\u002Fmain\u002F.blackbox\u002Fskills\u002Fui-ux-promax\u002FSKILL.md",[],[]]