Manual Setup vs Project Scaffolding
Hand-wiring a project from scratch versus using a scaffolding tool to generate the boilerplate. One of these is a learning exercise; the other ships software.
The short answer
Project Scaffolding over Manual Setup for most cases. Scaffolding gives you a tested, opinionated baseline in seconds — wired build, linting, and conventions the maintainers already debugged.
- Pick Manual Setup if learning how the pieces fit, the stack is too niche for any generator, or you need a deliberately minimal footprint with zero unused dependencies
- Pick Project Scaffolding if starting real work, want a maintained baseline, and would rather spend your first hour writing features than wiring a bundler
- Also consider: Scaffold first, then prune. Generate the baseline, delete what you don't use, and you get speed plus a lean tree — the best of both without re-deriving config from memory.
— Nice Pick, opinionated tool recommendations
Speed to first commit
This isn't close. A scaffolder like create-next-app, Vite, or cargo new hands you a running project in under a minute — dependencies resolved, build configured, dev server live. Manual setup means hunting down compatible versions, hand-writing tsconfig and bundler settings, and discovering the three peer-dependency conflicts the generator already solved for you. The first hour of a manual project is spent reproducing a solved problem, badly. People romanticize 'understanding every line,' but you don't earn understanding by retyping a webpack config from a 2019 blog post. You earn it by reading the generated one. Scaffolding collapses the boring part of a project's lifecycle — the part where nothing works yet and no feature exists — from a half-day into a coffee break. If your goal is shipping rather than suffering, that gap alone settles the question before any other factor is weighed.
Maintenance and rot
Manual setups quietly become bespoke nightmares. Every hand-chosen version, every clever custom build step, is config only you understand and only you can upgrade. When a dependency ships a breaking change, you're alone — no migration guide written for your snowflake structure, no community thread describing your exact layout. Scaffolded projects inherit a shape thousands of others share, which means upgrade codemods, Stack Overflow answers, and framework migration scripts actually apply to you. The maintainers carry the burden of keeping the baseline current; you ride along. The trap people fear — 'I don't know what this generated file does' — is real but solvable in an afternoon of reading. The manual trap is worse: config nobody documented, decisions nobody remembers, and a bus factor of one. Boring and standard beats clever and orphaned every single time you have to touch it a year later.
Bloat and the minimalism argument
Here's where manual setup earns its only honest point. Scaffolders are generous to a fault — they drop in example components, testing harnesses you may not want, ESLint rulesets with opinions, and dependencies you'll never import. A from-scratch project contains exactly what you put in it, which matters for libraries, tight bundle budgets, or genuinely exotic stacks no generator targets. But be honest about how often that applies. Most teams citing 'bloat' ship node_modules the size of a small moon anyway. Deleting four unused files from a scaffold takes two minutes; re-deriving a working build from nothing takes a morning. The minimalism win is real but narrow — it justifies manual setup for a published npm package or a constrained embedded target, not for the average app where 'lean' is a vibe nobody profiled.
Learning value, honestly weighed
The strongest case for manual setup is pedagogical, and it's legitimate — once. Wiring TypeScript, a bundler, and a test runner by hand teaches you what each layer does, so when a scaffolded project breaks you can actually fix it instead of cargo-culting. Every developer should do this the hard way at least a few times. But learning value is not a recurring justification. Doing manual setup for your fortieth project isn't education, it's nostalgia with a time cost. You don't relearn how a clutch works every time you drive. The mature move is to suffer through manual wiring deliberately, in a sandbox, as study — then use scaffolding for real work and read the generated config with the understanding you already earned. Treating every new project as a teaching moment is how people mistake busywork for craft.
Quick Comparison
| Factor | Manual Setup | Project Scaffolding |
|---|---|---|
| Time to running project | Half a day of version-hunting and config | Under a minute, dev server live |
| Long-term maintainability | Bespoke config only you understand | Standard shape with codemods and community fixes |
| Dependency footprint | Exactly what you add, nothing extra | Generous defaults, some unused files to prune |
| Learning value | Teaches every layer the hard way | Hides the wiring unless you read it |
| Default for real work | Re-solving a solved problem each time | Maintained, tested baseline to build on |
The Verdict
Use Manual Setup if: You're learning how the pieces fit, the stack is too niche for any generator, or you need a deliberately minimal footprint with zero unused dependencies.
Use Project Scaffolding if: You're starting real work, want a maintained baseline, and would rather spend your first hour writing features than wiring a bundler.
Consider: Scaffold first, then prune. Generate the baseline, delete what you don't use, and you get speed plus a lean tree — the best of both without re-deriving config from memory.
Scaffolding gives you a tested, opinionated baseline in seconds — wired build, linting, and conventions the maintainers already debugged. Manual setup is a fine teacher and occasionally the only option, but as a default it's just paying for knowledge you can acquire once and then automate forever.
Related Comparisons
Disagree? nice@nicepick.dev