- Home
- /
- CS Thinking
- /
- Mistakes
- /
- Software Design & Development
Common Mistakes in Software Design & Development
44 common pitfalls across 11 concepts, including 11 recurring stuck points
These are the pitfalls students hit across all 11 software design & development concepts, from Pseudocode, Flowchart and Design Specification onward. Each entry names the concept it comes from, so you can tell a slip from a genuine gap and go straight to the explanation.
There's no single 'correct' pseudocode format. It just needs to be clear and unambiguous to the reader.
Making pseudocode too language-specific by including syntax details like semicolons, brackets, or type declarations
Writing pseudocode that is too vague—each step should be clear enough that someone else could translate it to real code
Skipping pseudocode entirely and jumping straight to coding, which often leads to logic errors that are harder to fix later
Diamonds are for decisions (yes/no questions) only. Rectangles are for actions/processes.
Using the wrong shapes—diamonds must be for decisions only, rectangles for processes, ovals for start/end
Creating flowcharts with missing arrows or dead ends where the flow has nowhere to go
Making flowcharts too detailed or too abstract—aim for a level of detail that matches your audience
A spec describes what the system does, not how it's coded internally. Implementation details come later.
Writing vague requirements like 'the system should be fast' instead of measurable ones like 'pages load in under 2 seconds'
Including implementation details (which database to use, which framework) in a document that should focus on what, not how
Not involving end users or stakeholders in the specification process, leading to a spec that misses real needs
Agile doesn't mean 'no planning.' It means shorter cycles with frequent feedback, not chaos.
Skipping the requirements or design phase and jumping straight to coding, which leads to building the wrong thing
Treating the SDLC as purely linear—even in waterfall, you may need to revisit earlier phases when requirements change
Confusing agile with 'no process'—agile has structure (sprints, reviews, retrospectives) but emphasizes flexibility and feedback
Don't document what the code does (the code itself says that). Document why it does it — the reasoning and decisions.
Writing comments that restate the code instead of explaining the reasoning behind it
Letting documentation become outdated as code changes (stale docs are worse than none)
Documenting only happy paths and ignoring error handling and edge cases
Maintenance isn't just fixing bugs — it includes adapting to new requirements, improving performance, and preventing future problems.
Neglecting to update dependencies, leaving known security vulnerabilities unpatched
Making changes without understanding the existing code, introducing new bugs while fixing old ones
Rewriting working code from scratch instead of incrementally improving it, which is almost always riskier and more expensive
A commit is a snapshot of your project at a point in time, not a copy of the whole project. Git stores differences, not duplicates.
Making very large commits that bundle unrelated changes, making it hard to review or revert individual changes
Writing vague commit messages like 'fixed stuff' instead of describing what was changed and why
Not pulling the latest changes before starting work, leading to merge conflicts that could have been avoided
An interface describes what a module does and how to use it, not how it is implemented internally.
Exposing internal details that other modules should not depend on
Changing an interface without updating the code that depends on it
Leaving inputs or error cases unspecified so the contract is ambiguous
An edge case is not the same as an invalid case. Some edge cases are valid inputs that still need the correct output.
Testing only normal cases and skipping empty, zero, or maximum values
Treating every unusual input as invalid instead of deciding whether it is a valid boundary case
Writing code that assumes at least one item exists without checking
A unit test should focus on one behavior at a time. If it depends on half the program, it is no longer a small isolated test.
Writing tests that depend on external state instead of isolating the unit
Combining many behaviors into one large test so failures are hard to diagnose
Updating production code without rerunning the unit tests
UI (what it looks like) is not the same as UX (how it feels to use). A beautiful UI can still be frustrating to use.
Overloading the interface with too many options and controls, overwhelming the user
Being inconsistent with design patterns—using different button styles or navigation patterns on different screens
Not providing feedback after user actions, leaving users uncertain whether their action was registered