Skip to content
Skills Library
Programming · Building & coding

software-guidelines

/software-guidelines

Implement and review scoped code changes in a repository. Use for patch impact, dependent caller updates, repository conventions, and preserving unrelated work; use software-architecture for structural design and simplification decisions.

Repository
malskill ↗
Licence
MIT
Last repository change
13.11.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
1
Deprecation

No signals detected. Repository changed on 13.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Implement and review scoped code changes in a repository. Use for patch impact, dependent caller updates, repository conventions, and preserving unrelated work; use software-architecture for structural design and simplification decisions.

Original author description

Implement and review scoped code changes in a repository. Use for patch impact, dependent caller updates, repository conventions, and preserving unrelated work; use software-architecture for structural design and simplification decisions.

How it works

  1. Inspect the edit context
  2. Make the change complete and focused
  3. Verify and review the delivered patch
  4. Load deeper guidance when needed
Original SKILL.md headings · 36 lines, 657 words
SKILL.md preview
---
name: software-guidelines
description: "Implement and review scoped code changes in a repository. Use for patch impact, dependent caller updates, repository conventions, and preserving unrelated work; use software-architecture for structural design and simplification decisions."
license: MIT
metadata:
  author: AeonDave
  version: "1.3"
---

# Software Guidelines

Deliver a complete, reviewable change for the requested outcome. Apply this workflow to security tooling and its supporting code, from a local fix to a change spanning several modules.

## Inspect the edit context

- Read applicable instructions, inspect worktree status and relevant diffs, and examine the affected implementation before editing. Identify pre-existing changes and preserve them, including in files the task also touches. Re-read changed regions if another writer may have updated them; do not reset unrelated work.
- Follow the affected entry point through relevant callers, state changes, side effects, and tests. Verify that APIs and dependencies used by the patch exist in the checked version; distinguish existing capabilities from interfaces being introduced.
- Identify the requested behavior, what must remain stable, and the smallest useful acceptance check. Use repository conventions for routine choices. If an unresolved decision changes scope, a public contract, or data integrity, use `design-before-implementation`; continue independent authorized work.

## Make the change complete and focused

- Tie each part of the diff to the outcome or a necessary supporting change. Include required callers, tests, configuration, and documentation even when the request names only one function. Avoid unrelated features, dependency upgrades, formatting, and cleanup.
- When a symbol, signature, or data shape changes, inspect both its definition and consumers. Check indirect uses such as exports, registration strings, configuration keys, and serialized fields where relevant; a compile pass or literal-name search may miss these.
- Update the maintained source of generated artifacts and use the repository's generation workflow when required. Inspect generated changes for consistency and unrelated churn; do not patch only a derived copy that regeneration will overwrite.
- Reuse an existing convention or helper when its behavior fits. Do not reuse a similarly named abstraction without checking its error, ownership, and side-effect contracts. Add dependencies or abstractions only for a concrete requirement or boundary.
- Keep necessary validation, authorization, error propagation, and cleanup. Do not remove safeguards merely to shorten the patch or assume a failure path is impossible without establishing its preconditions.
- Allow requested simplification or a refactor needed to implement the change safely. Keep its preservation contract explicit and separate it from behavior changes where useful for review. Load [software-architecture](../software-architecture/SKILL.md), then its simplification reference when making those structural or readability decisions.
- Remove imports, parameters, helpers, and temporary diagnostics made obsolete by this change. Leave unrelated pre-existing cleanup for a separately scoped task; mention it only when it affects the outcome or poses a material risk.

## Verify and review the delivered patch

- Check the changed behavior and its affected consumers. Prefer an existing relevant check or reproducer; add a regression test when it protects a real behavior. Use `testing-reliability` when assertions, mocks, timing, or flaky results may mislead.
- For performance work, measure the relevant workload before changing it when practical; disclose an unavailable baseline and measurement limits. Use a user or project target when one exists; otherwise report the measured change and tradeoffs without inventing an acceptance threshold.
- Review the final diff against the requested outcome and initial worktree state. Look for missed consumers, accidental behavior changes, generated-file drift, obsolete code, and changes that belong to someone else. Keep fixes and their necessary supporting artifacts together.
- Use `verification-before-completion` for required checks, evidence reuse, failed gates, and completion wording. Passing checks support only the behavior they cover. Finish authorized implementation rather than stopping after a proposal or adding an approval gate for routine edits.

## Load deeper guidance when needed

- `software-architecture` — module boundaries, public contracts, state ownership, architectural tradeoffs, or behavior-preserving simplification.
- `implementation-planning` — dependent work, shared-file ownership, or a handoff that needs an executable plan.
- The relevant language pattern/testing skill — syntax, idioms, and executable checks for the actual stack.

For change sizing and separating substantial refactors, apply [Google's focused-change guidance](https://google.github.io/eng-practices/review/developer/small-cls.html#what-is-small) to the logical change and its consumers; preserve the repository's own review and testing policy.

Versions

The database has no other skills named software-guidelines.

Database snapshot: 13.11.2026 · package version 7ffeb093a586 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100review-guidelines
    Review code changes for compliance with CLAUDE.md guidelines. Use when the user says 'review guidelines', 'check guidelines', or 'validate against guidelines'.
  • 100software-architecture
    Design, evolve, and review software architecture, from small tools and libraries to multi-service systems. Use for module boundaries, domain models, public contracts, data ownership, quality trade-offs, architectural refactoring, and behavior-preserving simplification.
  • 100software-architecture
    Implements design patterns including Clean Architecture, SOLID principles, and comprehensive software design best practices. Use when designing systems, reviewing architecture, establishing patterns, or making structural decisions.
  • 90repository-engineering
    Audit, understand, modify, test, and document an existing software repository. Use for bug fixes, refactoring, feature implementation, build failures, CI issues, dependency changes, and engineering handoffs. Preserve project conventions and avoid unsupported claims.
  • 100software-planner
    Convert software feature requests, integrations, and change proposals into scoped implementation approaches, small development tasks, and measurable acceptance criteria. Use when a user asks for a technical plan, backlog, or implementation breakdown. Planning does not authorize…
  • 90doompi-development
    Implement scoped code changes in an existing repository and verify them with its native checks. Use when the user asks to build, change, or fix code, not for a review-only request.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.