Skip to content
Skills Library
Programming · Building & coding

software-engineering

/software-engineering

Design and implement cohesive, reusable, maintainable software with a strong first pass; identify the true source-of-truth during migration, reuse mature solutions, and diagnose root causes instead of patch chains. Use for coding, architecture, refactors, integrations, desktop apps and migrations.

Licence
MIT
Last repository change
01.11.2026

Assessment and security

90/ 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.
Content25 / 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
0
Deprecation

No signals detected. Repository changed on 01.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

Design and implement cohesive, reusable, maintainable software with a strong first pass; identify the true source-of-truth during migration, reuse mature solutions, and diagnose root causes instead of patch chains. Use for coding, architecture, refactors, integrations, desktop apps and migrations.

Original author description

Design and implement cohesive, reusable, maintainable software with a strong first pass; identify the true source-of-truth during migration, reuse mature solutions, and diagnose root causes instead of patch chains. Use for coding, architecture, refactors, integrations, desktop apps and migrations.

How it works

  1. Before writing production code
  2. Implement coherently
  3. When something fails
Original SKILL.md headings · 30 lines, 347 words
SKILL.md preview
---
name: software-engineering
description: Design and implement cohesive, reusable, maintainable software with a strong first pass; identify the true source-of-truth during migration, reuse mature solutions, and diagnose root causes instead of patch chains. Use for coding, architecture, refactors, integrations, desktop apps and migrations.
license: MIT
---

# Smart but lazy engineering

**Purpose.** Deliver the simplest reliable system that fulfills the whole task, not the most elaborate architecture or the largest number of commits.

## Before writing production code

- Identify the intended user behavior, hard constraints and **authoritative system**. For migrations, preserve the complete original behavior rather than adopting a partial target-language branch as the foundation.
- Check existing, proven modules, dependencies, prior assets and relevant open-source work; assess maintainership, license, security, compatibility and actual fit. Avoid both gratuitous reinvention and dependency bloat.
- Design one consistent architecture: data ownership, state transitions, failure paths, component contracts and integration points. If a structure needs pages of explanation to justify simple behavior, simplify it.
- For high-risk runtime foundations, use `minimal-model-thinking` to settle the minimum decisive uncertainty before large implementation.

## Implement coherently

- Small **cohesive** modules, reusable functions and components; named parameters, configuration and design tokens instead of scattered magic values.
- Do not split every three lines into a file or abstract imaginary future use-cases; readability and actual reuse matter more than file count.
- Separate domain functionality from UI so operations can be exercised through predictable interfaces and CLI/tests where appropriate.
- Keep professional depth in each critical domain. “Backend works” is not evidence that visual design is good.
- Prefer safe, reversible change paths, documented dependencies and stable public contracts over clever dynamic machinery.

## When something fails

- Observe concrete behavior/logs; search official docs, upstream issues, proven fixes and relevant source before improvising.
- Distinguish environmental/configuration defects from implementation defects. When useful, compare a minimal clean project with the failing one.
- Correct the **root cause** in the smallest structurally sound change. Avoid repeated patch-on-patch and reflexive rewrite; do not keep an intrinsically mismatched architecture merely because it can be forced to run.
- Run only the meaningful build, runtime or interface checks needed to establish correctness; if they fail, fix precisely.

**Success:** one coherent, working, maintainable product with proven critical mechanisms and no invisible omitted features.
**Avoid:** a rivet bolted to a nut—interfaces that superficially connect but fundamentally mismatch.

Versions

RepositoryScoreLicence
This page · Laaaaaaaam/wishwright-skills90MIT
asgeirtj/system_prompts_leaks100CC0-1.0
GAUSS-TPAC/software-engineering-skill100MIT
SterlingChin/marvin-template100MIT
officialdb/TES-SKILLS90Apache-2.0
hairyf/skills90MIT

Database snapshot: 13.11.2026 · package version a0dcbbb0fcfd (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

  • 90engineering-principles
    Apply the engineering principle that settles a coding or review decision, reading only the files that apply. Use when a choice needs a named principle such as fix root causes or explain the number; not for always-on repository rules (use AGENTS.md) and not to run a verification…
  • 100debugger
    Use this agent when you need to diagnose and fix bugs, identify root causes of failures, or analyze error logs and stack traces to resolve issues.
  • 90software-factory
    Deliver software through a canonical ticket queue, versioned repository, evaluations, CI/CD, live QA and measured follow-up; or improve that delivery system. Use for end-to-end software delivery and factory engineering.
  • 90architecture
    Design or review software architecture for new systems, major refactors, service boundaries, data ownership, technology choices, and migration plans. Use this skill when the task involves structural decisions or meaningful long-term technical trade-offs.
  • 100engineering-software-architect
    Use when Codex should act as the Software Architect specialist from Agency Agents. Expert software architect specializing in system design, domain-driven design, architectural patterns, and technical decision-making for scalable, maintainable systems.
  • 100software-architecture
    Guide for quality focused software architecture. This skill should be used when users want to write code, design architecture, analyze code, in any case that relates to software development.

Feedback and reports

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