Why Skipping Design Destroys Your Friday Afternoon – And How to Fix It

A Familiar Frustration

Jim McKeon, a software engineer writing on dev.to in July 2026, asserts that unresolved contradictions discovered during implementation are the single largest cause of career frustration. He claims design and debugging are often the same work performed at different times, but skipping design maximizes destructiveness.

Why This Matters

Key Insights

• Skipping design does not eliminate problems; it moves them to debugging, increasing cost and destructiveness (McKeon, 2026).
• Software development is a ‘wicked problem’ where requirements emerge as solutions are attempted (McKeon, 2026).
• ‘Reacting’ to mistakes after code is written forces rewrites; hunting problems before coding turns them into decisions (McKeon, 2026).
• Design produces code that is easier to understand, fix, and extend because its structure models the real process rather than accidental shape (McKeon, 2026).

Practical Applications

• Use case: Feature teams in high-pressure environments where deadlines conflict with underspecified asks
• Pitfall: Treating time spent thinking as stalling; opening VS Code immediately feels like progress but hides unresolved questions until they boil over.
• Mitigation: Perform lightweight design upfront to identify contradictions before writing code.
• Use case: Teams handling emergent requirements from customers who change their minds after seeing examples
• Pitfall: Assuming requirements are stable and complete; this leads to rework when customers reject the first iteration.
• Mitigation: Accept that software serves as a proof of concept for users to evaluate and refine.
• Use case: Developers facing ambiguous language in standups or specifications (e.g., debate over ‘send’ vs ‘push’)
• Pitfall: Misunderstanding terminology between stakeholders leads to incorrect assumptions baked into code.
• Mitigation: Clarify definitions early through explicit shared vocabulary.
• Use case: Engineers building complex features with multiple dependencies
• Pitfall: Pushing unresolved questions to the back burner to protect deadlines; they surface later when changes are expensive.
• Mitigation: Proactively discover unsupported assumptions and hidden dependencies during design phase.

References:

• https://dev.to/mckeondev/design-or-debug-2jpf