All bites
The whole library, newest first. Filter by what you are here for, or pick a topic if you already know.
4247 bites
Page 180
SMART Goals: From Vague Hopes to Actionable Plans
SMART criteria turn vague hopes into concrete plans by forcing goals to be Specific, Measurable, Achievable, Relevant, and Time-bound. It's used in project planning and performance reviews.
Radical Candor: Care Personally, Challenge Directly
Radical Candor is a feedback framework that combines caring personally with challenging directly. It's used to give clear, kind guidance—both praise and criticism—that helps people grow.
The 4Ls Retrospective: Loved, Loathed, Longed For, Learned
The 4Ls retrospective is a structured way to capture a team's feelings after a project. It asks what they Loved, Loathed, Longed for, and Learned to create an action plan. A common pitfall is only focusing on negatives, missing key insights from the other Ls.
Double-Loop Learning: Question the 'Why', Not Just the 'How'
Double-loop learning means questioning the 'why' behind your work, not just fixing the 'how'. Instead of only correcting errors, you challenge the underlying goals. This is crucial in retrospectives when a team realizes their entire approach was flawed.
Actionable Agile Metrics: Predicting 'Done'
Stop guessing 'done' and start forecasting with data. Actionable Agile Metrics use historical flow data—like cycle time and throughput—to answer 'When will it be done?' for customers who need predictability.
Test-Driven Development: The Red, Green, Refactor Cycle
Test-Driven Development (TDD) flips the script: you write a failing test *before* the feature code. This 'Red, Green, Refactor' cycle ensures every piece of code is testable. It's common in agile for building robust features.
Behavior-Driven Development (BDD): Requirements as Tests
BDD turns requirements into executable tests using a shared, human-readable language. Use it for complex features where business and tech teams need to align. The footgun is writing BDD scenarios *after* coding, missing the collaborative design benefit.
Refactoring: Cleaning Code Without Breaking It
Refactoring is like renovating a house's internals without changing its outward appearance. It improves code design and readability without altering external behavior, making it easier to maintain or extend.
SOLID Principles: Writing Maintainable Object-Oriented Code
SOLID principles are five design rules for writing maintainable object-oriented code. They guide you toward creating flexible systems that are easy to change. The footgun is treating them as rigid laws, leading to over-engineered and complex solutions.
Trunk-Based Development: One Mainline to Rule Them All
Trunk-Based Development means all developers commit to a single shared branch, main or trunk. This is common in CI/CD environments for frequent updates.
Simple Design: The Simplest Thing That Could Possibly Work
Simple Design means building only what's needed now, not what you might need later. In agile projects like Extreme Programming, this keeps code lean for changing requirements.
YAGNI: You Ain't Gonna Need It
YAGNI is a principle of radical simplicity: don't build features now just because you *think* you'll need them later. It forces focus on current requirements, preventing wasted effort on speculative work.
DRY: Don't Repeat Yourself
DRY means every piece of knowledge has one single, authoritative representation in your system. This applies to business logic, config, or docs; a change in one place updates everywhere.
The Test Pyramid: Fast Feedback, Stable Code
The Test Pyramid is a strategy for balancing automated tests: write many fast unit tests, fewer integration tests, and very few slow end-to-end tests. It guides CI/CD pipelines to catch failures quickly. The footgun is over-relying on slow E2E tests.
Code Smells: Indicators of Deeper Problems, Not Flaws
A code smell is a surface-level hint, like a long method, that suggests a deeper design problem. It's an indicator, not a definitive flaw. The footgun is blindly "fixing" every smell; a smell is a reason to investigate, not an automatic command to refactor.
Strangler Fig Pattern: Replace Legacy Systems Safely
The Strangler Fig pattern lets you replace a legacy system by gradually growing a new one around it, eventually choking out the old code. It's used for modernizing critical systems where a "big bang" rewrite is too risky, routing traffic feature by feature.
Contract Testing: Test Interfaces, Not Integrations
Contract testing ensures services work together without slow integration tests. It's a formal agreement where a 'consumer' defines its needs, and a 'provider' proves it can meet them.
ATDD: Aligning Code with Business Needs Before You Build
Acceptance Test-Driven Development (ATDD) is a communication framework where business, developers, and testers write acceptance tests together *before* coding begins. This ensures everyone understands the requirements.
Empathy Mapping: Seeing Through Your User's Eyes
An empathy map is a tool for a team to build a shared picture of a user's mind, not just their actions. It's used in UX design to align on user needs before building. The footgun is treating it as a one-time checklist instead of.
Value Proposition Canvas: Map Customer Needs to Product Features
The Value Proposition Canvas maps customer needs to product features to ensure you're building something people want. It connects customer "jobs," "pains," and "gains" to your product's features.