For most of my career, writing software felt like construction. You laid foundations (schemas, models, core abstractions) and built upward from there. Each floor had to be solid before you added weight to it. You wrote the tests, hardened the edges, and only moved up once the ground beneath you was stable. It was a good discipline. It forced you to think carefully about what each layer needed to be before you committed to it.
The trade-off was that you often discovered the wrong thing was solid. You had poured concrete for a building that needed to be somewhere else.
The shift.
The way I work now feels more like sculpting. You start with the whole mass: a rough, oversized shape that contains the final form somewhere inside it. The shape is wrong everywhere, but it is all there. Then you work inward. Broad strokes first: the main planes, the overall proportions. Then finer and finer passes until the detail emerges and the thing becomes itself.
In software terms: I now reach for the entire surface of a feature before any of it is correct. Routes, controllers, components, migrations: all of it, rough. The shape is there. Then I start chipping. This field should be nullable. This component wants to be split. This query will not survive real data. Each pass brings it closer to what it needed to be, and the whole time I can see where it is going.
Why they feel different.
The builder's instinct is to not move forward until the current thing is right. The sculptor's instinct is to not get attached to any part until the whole is visible. The builder's risk is over-engineering foundations for the wrong building. The sculptor's risk is mistaking an early rough shape for the finished piece: shipping the chip-marks as character.
I have made both mistakes. I have spent days perfecting an abstraction for a feature that pivoted the following week. I have also convinced myself a rough sculpt was done because it broadly worked and I was tired of looking at it.
What changed.
Part of it is experience: I can read the shape of a system faster than I used to, which makes the rough first pass less rough. When the broad strokes are closer to right, each subsequent pass costs less.
Part of it is the tools. AI-assisted development dramatically accelerates the first pass. You can have the whole rough structure in place in hours rather than days, which makes the sculpting approach viable for scopes that previously demanded the builder's careful sequencing just to stay manageable.
Neither approach is always right. Some problems (a payment integration, a security boundary, anything where a wrong foundation costs you everything) still demand the builder's rigour. But for most product work, I have found that seeing the whole thing wrong is a faster path to seeing it right than building only what you are certain of.