---
name: pragmatic-programmer
description: "Software craftsmanship principles from The Pragmatic Programmer. Use this skill when discussing best practices, debugging strategies, career development, or pragmatic approaches to software development. Auto-activates for DRY violations, debugging sessions, and development workflow improvements."
---

# The Pragmatic Programmer Reference

A comprehensive reference for pragmatic software development principles based on "The Pragmatic Programmer" by David Thomas and Andrew Hunt. This skill provides timeless advice for becoming a better developer.

## When This Skill Activates

This skill automatically activates when you:
- Discuss software development best practices
- Need debugging strategies
- Consider code duplication (DRY)
- Think about tooling and automation
- Discuss project estimation or planning
- Review development workflows

## Core Philosophy

> "Care about your craft."
> "Think about your work."

Pragmatic programmers:
- Take responsibility for their career and work
- Don't make excuses—provide options
- Are agents of change, not victims of circumstance
- Continuously learn and adapt

## Quick Reference

### Foundational Principles
| Principle | Summary |
|-----------|---------|
| [DRY - Don't Repeat Yourself](principles/dry.md) | Every piece of knowledge has a single representation |
| [Orthogonality](principles/orthogonality.md) | Keep things independent and decoupled |
| [Reversibility](principles/reversibility.md) | Make decisions reversible; avoid lock-in |
| [Tracer Bullets](principles/tracer-bullets.md) | Get feedback fast with end-to-end skeleton |
| [Prototypes](principles/prototypes.md) | Learn before committing; throw away prototypes |
| [Domain Languages](principles/domain-languages.md) | Program close to the problem domain |
| [Estimating](principles/estimating.md) | Learn to give accurate estimates |

### Practical Techniques
| Practice | Summary |
|----------|---------|
| [The Power of Plain Text](practices/plain-text.md) | Keep knowledge in accessible format |
| [Shell Games](practices/shell-games.md) | Master the command line |
| [Debugging](practices/debugging.md) | Fix the problem, not the blame |
| [Text Manipulation](practices/text-manipulation.md) | Learn text processing tools |
| [Code Generators](practices/code-generators.md) | Write code that writes code |
| [Design by Contract](practices/design-by-contract.md) | Define rights and responsibilities |
| [Assertive Programming](practices/assertive-programming.md) | If it can't happen, use assertions |
| [Decoupling](practices/decoupling.md) | Minimize dependencies between modules |
| [Refactoring](practices/refactoring.md) | Improve code continuously |
| [Testing](practices/testing.md) | Test early, test often, test automatically |
| [Automation](practices/automation.md) | Don't use manual procedures |

## The Pragmatic Tips

Key tips from the book:

1. **Care About Your Craft** - Why spend your life developing software unless you care?
2. **Think! About Your Work** - Turn off autopilot and take control
3. **Provide Options, Don't Make Excuses** - Don't say it can't be done; explain what can be done
4. **Don't Live with Broken Windows** - Fix bad designs and wrong decisions when you see them
5. **Be a Catalyst for Change** - Show people the future and help them participate
6. **Remember the Big Picture** - Don't get so focused you forget what you're doing
7. **Make Quality a Requirements Issue** - Get users involved in determining quality
8. **Invest Regularly in Your Knowledge Portfolio** - Make learning a habit
9. **Critically Analyze What You Read and Hear** - Don't be swayed by vendors or media hype
10. **It's Both What You Say and How You Say It** - Communication matters

## The Knowledge Portfolio

Treat your knowledge like a financial portfolio:

- **Invest regularly** - Learn something new routinely
- **Diversify** - Know many different technologies
- **Manage risk** - Balance safe tech with high-risk/high-reward
- **Buy low, sell high** - Learn emerging tech before it becomes mainstream
- **Review and rebalance** - Reassess periodically

### Suggestions:
- Learn a new language every year
- Read a technical book each month
- Read non-technical books too
- Take classes
- Participate in local user groups
- Experiment with different environments
- Stay current (newsletters, blogs, conferences)

## Communication

- Know what you want to say
- Know your audience
- Choose the right moment
- Choose a style
- Make it look good
- Involve your audience
- Be a listener
- Get back to people
- Documentation is part of the project, not after

## Language Translation Notes

Examples use generic pseudocode. Adapt to your language:
- **PHP**: `class`, `function`, `->`, type hints
- **JavaScript/TypeScript**: `class`, arrow functions, `.`
- **Python**: `class`, `def`, `.`, type hints
- **Java/C#**: Direct mapping with access modifiers

---

*Based on concepts from "The Pragmatic Programmer: Your Journey to Mastery" by David Thomas and Andrew Hunt.*