Development Fundamentals
Overview
This skill covers the foundational knowledge every software developer should command — drawn from canonical published works and industry-proven practices. It spans from low-level algorithms through code craftsmanship to system-level architecture.
Knowledge Map
┌─────────────────────────────────────────────────────────┐
│ Architecture │
│ Microservices, Monoliths, DDD, Event-Driven, │
│ Hexagonal, Well-Architected Frameworks │
├─────────────────────────────────────────────────────────┤
│ Frontend │ Backend │
│ SPA, PWA, Micro-frontends, │ Data Modeling, API │
│ SSR, Islands Architecture │ Design, Caching, Auth │
├─────────────────────────────────────────────────────────┤
│ Integration Patterns │ Design Patterns │
│ EIP: Messaging, Routing, │ GoF: Creational, │
│ Transformation, Endpoints │ Structural, Behavioral │
├─────────────────────────────────────────────────────────┤
│ Algorithms & Data Structures │
│ Sorting, Searching, Graphs, DP, Combinatorial │
├─────────────────────────────────────────────────────────┤
│ Craftsmanship │
│ Clean Code, Clean Architecture, SOLID, 12-Factor, │
│ Refactoring, Boy Scout Rule │
└─────────────────────────────────────────────────────────┘
Canonical Works
| Book |
Author |
Covers |
| Design Patterns |
Gamma, Helm, Johnson, Vlissides (GoF) |
23 object-oriented patterns |
| Enterprise Integration Patterns |
Hohpe & Woolf |
Messaging, routing, transformation |
| The Art of Computer Programming |
Donald Knuth |
Algorithms, data structures, combinatorics |
| Clean Code |
Robert C. Martin |
Naming, functions, formatting, comments |
| Clean Architecture |
Robert C. Martin |
Dependency rule, boundaries, layers |
| Refactoring |
Martin Fowler |
Code smells, refactoring catalog |
| Domain-Driven Design |
Eric Evans |
Bounded contexts, aggregates, ubiquitous language |
| Building Microservices |
Sam Newman |
Service decomposition, communication, deployment |
| The Pragmatic Programmer |
Hunt & Thomas |
Career, approach, tools, pragmatic philosophy |
| The Twelve-Factor App |
Adam Wiggins (Heroku) |
Cloud-native application methodology |
| Release It! |
Michael Nygard |
Stability patterns, capacity, deployment |
| Fundamentals of Software Architecture |
Richards & Ford |
Architecture styles, characteristics, decisions |
Choosing the Right Pattern Category
| Problem |
Look In |
| Object creation complexity |
Design Patterns → Creational |
| Composing objects / adapting interfaces |
Design Patterns → Structural |
| Object communication / state management |
Design Patterns → Behavioral |
| Service-to-service messaging |
Integration Patterns |
| Algorithm selection / optimization |
Algorithms |
| Code readability and maintainability |
Craftsmanship |
| System decomposition and boundaries |
Architecture |
| Client-side application structure |
Frontend |
| Server-side data and API structure |
Backend |
Best Practices
- Learn patterns as a vocabulary, not a checklist — apply them when the problem calls for it, not preemptively.
- Start with the simplest architecture that works (monolith), evolve toward complexity (microservices) only when you have evidence you need it.
- Apply the Boy Scout Rule: leave code better than you found it, every time you touch it.
- Use SOLID principles as guardrails for daily decisions, not just for greenfield design.
- Prefer composition over inheritance — most GoF patterns are variations of this principle.
- Study algorithms for problem-solving intuition, not memorization — know when to reach for a graph algorithm vs. dynamic programming.
- Keep integration patterns in mind whenever systems need to communicate — messaging solves problems that synchronous calls create.
1---2name: dev3description: |4 Use when working with fundamental software development knowledge — patterns, algorithms, architecture, and craftsmanship principles drawn from canonical published works.5 USE FOR: development fundamentals, pattern selection, architecture decisions, algorithm choice, code quality principles, choosing between architectural styles6 DO NOT USE FOR: specific pattern implementations (use sub-skills: design-patterns, integration-patterns, algorithms, etc.), testing strategy (use testing), infrastructure (use iac)7license: MIT8metadata:9 displayName: "Development Fundamentals"10 author: "Tyler-R-Kendrick"11compatibility: claude, copilot, cursor12references:13 - title: "Refactoring.Guru — Design Patterns"14 url: "https://refactoring.guru/design-patterns"15 - title: "Enterprise Integration Patterns — Hohpe & Woolf"16 url: "https://www.enterpriseintegrationpatterns.com/"17 - title: "Martin Fowler — Software Architecture Guide"18 url: "https://martinfowler.com/architecture/"19---2021# Development Fundamentals2223## Overview24This skill covers the foundational knowledge every software developer should command — drawn from canonical published works and industry-proven practices. It spans from low-level algorithms through code craftsmanship to system-level architecture.2526## Knowledge Map2728```29┌─────────────────────────────────────────────────────────┐30│ Architecture │31│ Microservices, Monoliths, DDD, Event-Driven, │32│ Hexagonal, Well-Architected Frameworks │33├─────────────────────────────────────────────────────────┤34│ Frontend │ Backend │35│ SPA, PWA, Micro-frontends, │ Data Modeling, API │36│ SSR, Islands Architecture │ Design, Caching, Auth │37├─────────────────────────────────────────────────────────┤38│ Integration Patterns │ Design Patterns │39│ EIP: Messaging, Routing, │ GoF: Creational, │40│ Transformation, Endpoints │ Structural, Behavioral │41├─────────────────────────────────────────────────────────┤42│ Algorithms & Data Structures │43│ Sorting, Searching, Graphs, DP, Combinatorial │44├─────────────────────────────────────────────────────────┤45│ Craftsmanship │46│ Clean Code, Clean Architecture, SOLID, 12-Factor, │47│ Refactoring, Boy Scout Rule │48└─────────────────────────────────────────────────────────┘49```5051## Canonical Works5253| Book | Author | Covers |54|------|--------|--------|55| *Design Patterns* | Gamma, Helm, Johnson, Vlissides (GoF) | 23 object-oriented patterns |56| *Enterprise Integration Patterns* | Hohpe & Woolf | Messaging, routing, transformation |57| *The Art of Computer Programming* | Donald Knuth | Algorithms, data structures, combinatorics |58| *Clean Code* | Robert C. Martin | Naming, functions, formatting, comments |59| *Clean Architecture* | Robert C. Martin | Dependency rule, boundaries, layers |60| *Refactoring* | Martin Fowler | Code smells, refactoring catalog |61| *Domain-Driven Design* | Eric Evans | Bounded contexts, aggregates, ubiquitous language |62| *Building Microservices* | Sam Newman | Service decomposition, communication, deployment |63| *The Pragmatic Programmer* | Hunt & Thomas | Career, approach, tools, pragmatic philosophy |64| *The Twelve-Factor App* | Adam Wiggins (Heroku) | Cloud-native application methodology |65| *Release It!* | Michael Nygard | Stability patterns, capacity, deployment |66| *Fundamentals of Software Architecture* | Richards & Ford | Architecture styles, characteristics, decisions |6768## Choosing the Right Pattern Category6970| Problem | Look In |71|---------|---------|72| Object creation complexity | Design Patterns → Creational |73| Composing objects / adapting interfaces | Design Patterns → Structural |74| Object communication / state management | Design Patterns → Behavioral |75| Service-to-service messaging | Integration Patterns |76| Algorithm selection / optimization | Algorithms |77| Code readability and maintainability | Craftsmanship |78| System decomposition and boundaries | Architecture |79| Client-side application structure | Frontend |80| Server-side data and API structure | Backend |8182## Best Practices83- Learn patterns as a vocabulary, not a checklist — apply them when the problem calls for it, not preemptively.84- Start with the simplest architecture that works (monolith), evolve toward complexity (microservices) only when you have evidence you need it.85- Apply the Boy Scout Rule: leave code better than you found it, every time you touch it.86- Use SOLID principles as guardrails for daily decisions, not just for greenfield design.87- Prefer composition over inheritance — most GoF patterns are variations of this principle.88- Study algorithms for problem-solving intuition, not memorization — know when to reach for a graph algorithm vs. dynamic programming.89- Keep integration patterns in mind whenever systems need to communicate — messaging solves problems that synchronous calls create.
Tyler-R-Kendrick