Next AI Draw.io
draw.io diagrams your AI agent draws on a live browser canvas that you can also edit by hand
Claude Code skill: Software design philosophy guide based on A Philosophy of Software Design by John Ousterhout
If you made this, paste this code into your README. The badge links back to this page.
[](https://mcp.popnx.com/en/skills/luoling8192-software-design-philosophy-skill)MCP servers that connect the AI to services for the same work
draw.io diagrams your AI agent draws on a live browser canvas that you can also edit by hand
Create, inspect, validate, and save editable 3D building scenes with Pascal's MCP server.
Verified React chart generation: select, validate, repair, render, and inspect charts through MCP.
Same kind of work, ordered like the Skills list
| This one software-design-philosophy-skill | impeccable | diagram-design | frontend-slides | guizang-ppt-skill | |
|---|---|---|---|---|---|
| Maker | luoling8192 | pbakaus | cathrynlavery | zarazhangrui | op7418 |
| Skills | 1 | 1 | 1 | 1 | 1 |
| GitHub stars | 359 | 111,852 | 67,796 | 32,458 | 29,958 |
| Last code change | Jul 11, 2026 | Nov 17, 2026 | Nov 13, 2026 | Jun 24, 2026 | Oct 30, 2026 |
| License | MIT | Apache-2.0 | MIT | MIT | AGPL-3.0 |
1 skills (instruction sets) by luoling8192 that an AI reads and follows · not an MCP server
MCP = the hands
Connects the AI to an outside service or data, such as reading Notion or creating an invoice. A program or server has to be running.
Skill = the manual
A text file that teaches the AI how to do a task. It connects to nothing.
Some overlap: a few Skills run scripts that call tools, and a few MCP servers only send knowledge. Start from the task you want done.
Claude CodeCodex
From the maker’s README and the folders in the repo
GitHub account luoling8192 (person), 8 years old
★ 359 stars, few users so far · code last changed Jul 11, 2026
No, plain text files the AI reads and follows
No scripts, so it does not go online by itself
No hooks or writes to machine settings found
Checked automatically from the repo files at commit 1a93214 (read only, nothing was run). Not a safety guarantee: read it and decide for yourself
First: which AI do you use?
Pick your app and this page shows only how to install it there
Uploading to claude.ai would fail: the description is over 200 characters (689). Use "Let the AI install it" instead
Copy this sentence and paste it into a Claude Code chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Restart Claude Code, then type /software-design-philosophy-skill or ask for a matching task and Claude picks it up
Checked against official docs Nov 12, 2026 · Source: code.claude.com
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Already installed? Check first · Open Terminal, type this command and press Enter
node -vMac: press ⌘ + Space, type Terminal, press Enter
Windows: open Start, type Windows PowerShell, then Open
Not installed: Open the official download page, pick the LTS version and the click-through installer: .pkg on Mac · .msi on Windows. Double-click and follow it to the end. No curl command needed
Open the Node.js download page ↗
When it’s done, close Terminal, open it again and run the same command. You should see a version number: node -v
Install once; it works for everything that needs Node.js
Checking the commands · copy buttons appear once they pass
Copied from the maker’s README; it downloads and runs the maker’s code
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
Checking the commands · copy buttons appear once they pass
The ChatGPT desktop app has Codex built in, and Codex reads skills from ~/.agents/skills
Open Codex in the ChatGPT desktop app and paste this sentence into the chat
The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Put the software-design-philosophy folder at ~/.agents/skills/software-design-philosophy
~ is your home folder ($HOME)
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
Checking the commands · copy buttons appear once they pass
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
Skills you install yourself do not work here; only skills that come with a plugin from the directory
To use this skill with ChatGPT, use the ChatGPT desktop app as above
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
Copy this sentence and paste it into a Codex chat · Works in Codex inside the ChatGPT desktop app, Codex CLI and the IDE extension
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Codex picks up newly installed skills by itself; if one does not show up, restart Codex · To use it: in ChatGPT type @ and pick the skill · in Codex CLI or the IDE extension run /skills or type $ and the skill name
Checked against official docs Nov 15, 2026 · Source: learn.chatgpt.com
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
Checking the commands · copy buttons appear once they pass
Copy this sentence and paste it into a Cursor chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
In Cursor’s Agent chat, type / and pick software-design-philosophy-skill
Checked against official docs Nov 12, 2026 · Source: cursor.com
A Skill is instructions the AI will follow. Read the files before installing, and install only from makers you trust.
Mac: press Command+Space and type Terminal · Windows: the command below does not work in PowerShell; use “Let AI install it” above instead
This downloads the repo to a temporary folder and copies only the folders that contain a SKILL.md
Checking the commands · copy buttons appear once they pass
For other apps that read skills. The sentence gives the paths for Claude Code, Codex and Cursor so the AI picks the one for your app · Copy this sentence into the app’s chat
For one project, paste it into a chat that is open in that project’s folder · The AI always shows you the path before installing
The AI tells you what it will do first and asks your permission at every step
Checked against official docs Nov 12, 2026 · Source: code.claude.com, learn.chatgpt.com, cursor.com
Other apps that support Agent Skills (such as Gemini CLI or GitHub Copilot) use different folders. Check that app’s guide, then copy the folder with the SKILL.md there.
Skill folders checked against the official Claude Code, Codex and Cursor guides on Nov 11, 2026
The text below comes from the maker’s repo, not from PopNx MCP
Showing the first 8,000 characters · Open the full file on GitHub
---
name: software-design-philosophy
description: >
Software design philosophy guide based on John Ousterhout's "A Philosophy of Software Design."
Use this skill during: code reviews, architecture discussions, API design, module decomposition decisions,
refactoring guidance, complexity analysis, naming and commenting improvements, error handling strategy design.
Trigger when the user mentions "code is too complex", "how to split modules", "interface design",
"reduce coupling", "deep/shallow modules", "information leakage", "error handling", "code readability",
"design philosophy", "pull complexity down", "define errors out of existence", or similar topics.
Also trigger for any code review where design quality feedback is requested.
---
# A Philosophy of Software Design — Distilled Guide
> Source: John Ousterhout, *A Philosophy of Software Design*
> Central thesis: **The core challenge of software design is managing complexity.**
---
## I. Complexity: Know the Enemy
### Definition
Complexity is anything related to the structure of a software system that makes it **hard to understand and modify**. Complexity is not the same as system size — a small system can be complex, and a large well-designed system can be manageable.
### Three Symptoms of Complexity
1. **Change Amplification**: A seemingly simple change requires code modifications in many different places.
2. **Cognitive Load**: Developers must absorb a large amount of information to complete a task safely. Note: fewer lines of code ≠ simpler — sometimes more code is actually simpler because it reduces cognitive load.
3. **Unknown Unknowns**: It's unclear which code must be modified or what information is needed to complete a task. This is the most dangerous symptom.
### Two Root Causes
1. **Dependencies**: A piece of code cannot be understood or modified in isolation; it relates to other code that must also be considered.
2. **Obscurity**: Important information is not obvious — vague names, missing docs, implicit conventions, hidden constraints.
### Key Insight
- **Complexity is incremental**: It's not caused by a single catastrophic error; it accumulates through thousands of small decisions.
- Therefore you must adopt a **zero-tolerance** mindset — every bit of "minor" complexity matters.
---
## II. Strategic vs. Tactical Programming
### Tactical Programming (Anti-pattern)
- Goal: get features working as quickly as possible.
- Mindset: "Just make it work", "We'll refactor later."
- Result: complexity accumulates fast, tech debt spirals out of control.
### Strategic Programming (Recommended)
- Goal: produce great design; working code is a byproduct.
- Mindset: **invest roughly 10–20% of development time in design improvements.**
- Practices:
- Look for opportunities to improve design with every change.
- Working code is not enough — design quality matters equally.
- The increments of software development should be **abstractions**, not features.
---
## III. Deep Modules: The Most Important Design Concept
### Core Metaphor
Think of a module as a rectangle:
- **Width** = complexity of its interface
- **Height/Depth** = amount of functionality hidden inside
**Deep module**: simple interface, rich implementation. (Good design)
**Shallow module**: complex interface, does very little. (Bad design 🚩)
### Classic Examples
- **Deep**: Unix file I/O — just 5 syscalls (open, read, write, lseek, close) expose a powerful file system.
- **Shallow**: Java I/O — reading a file requires composing FileInputStream, BufferedInputStream, ObjectInputStream, etc.
### Practical Principles
- Design interfaces so the **most common usage is as simple as possible**.
- A simple interface matters more than a simple implementation.
- Rare use cases can accept more complex calling patterns, but the common path should never pay for them.
---
## IV. Information Hiding and Information Leakage
### Information Hiding
- Each module should encapsulate **design decisions** (knowledge), exposing only a simplified interface.
- Hidden information includes: data structures, algorithms, low-level mechanisms, policy decisions.
- Information hiding minimizes inter-module dependencies.
### Information Leakage 🚩 Red Flag
- When the same design decision is reflected in multiple modules, information has leaked.
- **Temporal decomposition** is a common source: splitting modules by execution order (rather than by information hiding) causes steps to share excessive knowledge.
### Fixing Leakage
- Merge shared knowledge into a single module.
- If merging isn't possible, unify the shared information behind a single deep module.
---
## V. General-Purpose vs. Special-Purpose Modules
### Core Principle: General-purpose modules are usually deeper.
- A general interface is simpler than a specialized one because it covers more use cases with fewer methods.
- When designing a new module, ask: **What is the most general-purpose interface that can satisfy my current needs?**
### Judgment Criteria
- The interface should be general enough to support multiple use cases without modification.
- But the implementation can do only what's currently needed (don't over-build).
- General-purpose and special-purpose code should be **cleanly separated**.
---
## VI. Different Layers, Different Abstractions
### Principle
- A software system has multiple layers; each layer should provide a **different abstraction** from its adjacent layers.
- If two layers have similar abstractions, the layering is wrong.
### Pass-Through Method 🚩 Red Flag
- A method that does almost nothing except forward its arguments to another method with a similar signature.
- This signals that the layers don't offer different abstractions — the responsibility split is flawed.
### Pass-Through Variable 🚩 Red Flag
- A variable threaded from top to bottom through layers that don't use it.
- Solutions: context objects, dependency injection, or rethinking module boundaries.
---
## VII. Pull Complexity Downward
### Core Principle
- When complexity is unavoidable, the **module should absorb it internally** rather than pushing it to callers.
- Most modules have more users than developers — it's better for developers to suffer than for every user to suffer.
### Anti-patterns
- Turning hard decisions into configuration parameters and pushing them to sysadmins.
- Throwing exceptions for uncertain conditions and letting callers handle them.
- These save effort in the short term but amplify complexity system-wide.
---
## VIII. Define Errors Out of Existence
### Core Insight
- Exception handling is one of the biggest sources of complexity.
- Reducing the number of exceptions that must be handled is one of the best techniques for reducing complexity.
### Strategies
1. **Redefine semantics so the error condition cannot arise.**
- Example: `unset(key)` succeeds even if the key doesn't exist — it simply guarantees "after the call, the key does not exist."
- Example: `substring(start, end)` auto-clips out-of-bounds parameters instead of throwing.
2. **Exception Masking**: Detect and handle exceptions at a low level so they never reach callers.
3. **Exception Aggregation**: Handle multiple exception types in one centralized place instead of scattering handlers at every call site.
### Important Distinction
- This is not about ignoring errors — it's about **designing better semantics so error conditions simply aren't errors**.
- Errors that truly require reporting (e.g., lost network packets) must still be handled properly.
---
## IX. Design It Twice
- For any important design decision, conceive **at least two different approaches** before choosing.
- Even if the first idea seems great, force yourself to think of an alternative.
- Comparison dimensions: interface simplicity, generality, performance, implementation difficulty.
- This habit significantly improves design quality.
---
## X. The Philosophy of Comments
### Why Write CommentsAsk, share a tip or report that it does not work. Sorted by what people marked helpful.
No posts yet. Be the first to ask or share.
Posts here are written by users, not the PopNx team.