Earth to earth.
Ashes to ashes.
Dust to dust.
We’ve watched this cycle
turn and spin.
The end looks new.
The start walks in.
There was a time
we wrote it all,
no prefab parts,
no vendor wall.
Line by line
and file by file,
we shaped each app
in our own style.
If something broke,
we knew the seam.
We built the guts.
We drew the scheme.
Then came the age
of snap and click.
Why forge your own
when parts are quick?
A module here.
A package there.
Import the rest.
Ship and share.
Framework strong.
Convention tight.
Move it fast.
It mostly worked right.
And it did.
It truly did.
Standard rails
on every grid.
But cycles turn.
They always do.
The old comes back
wearing new.
Now we prompt.
Now we guide.
And code appears
at our side.
No hunting stacks
for “close enough.”
No bending logic
to fit their stuff.
Describe the flow.
Define the need.
The system writes
at typing speed.
Full circle arc.
Around we sweep.
Back to scratch—
but faster, deep.
Earth to earth.
Ashes to ashes.
Dust to dust.
We wrote from scratch.
We write again.
Only now
we don’t write alone.
What once was costly,
slow and rare,
is once again
the way we build with care.
Dust to dust.
And code to code.
There was a time when almost all software was bespoke.
If you wanted an application, you built it. Period. There was no marketplace of interchangeable parts. No ocean of open source packages. No SaaS layer to snap in and configure. You hired developers. You defined requirements. You wrote code that matched your business because there was no alternative.
It was slower. It was more expensive. It was also deeply aligned with the organization it served. The software reflected how the business actually operated, not how a vendor imagined it should.
Then the component era arrived.
Open source exploded. Frameworks matured. SaaS vendors multiplied. The argument was simple and compelling. Why reinvent what already exists? Why write authentication when someone else has perfected it? Why build billing when Stripe is a click away? Why construct infrastructure when the cloud gives you primitives on demand?
We moved from crafting systems to assembling them.
That was not laziness. It was progress. Standardization lowered cost. Reuse improved security. Shared abstractions let teams move faster. DevOps matured because components were predictable. Platform engineering emerged because repeatability won.
For two decades, success meant stitching together the right stack.
But AI-assisted development changes the economics again.
When generating clean, context-aware code becomes nearly instantaneous, the tradeoff between build and buy begins to blur. Not because SaaS disappears. Not because frameworks vanish. But because writing custom logic is no longer the bottleneck it once was.
If it takes seconds to generate a tailored workflow instead of days to adapt a generic one, the calculus shifts.
And that brings craftsmanship back into the conversation.
For years, craftsmanship in enterprise software often meant knowing which components to choose and how to integrate them cleanly. Architectural judgment mattered more than hand-written implementation.
Now we are rediscovering something different.
Craftsmanship is shifting from selection to specification.
The skill is no longer just picking the right tools. It clearly describes the system you want, understanding your domain deeply enough to express it precisely, and guiding AI to generate code that reflects that understanding.
In the bespoke era, craftsmanship lived in syntax.
In the component era, it lived in integration.
In the AI era, it may live in intent.
That is not a small shift.
Because when software becomes easier to shape around the business, the business no longer has to contort itself around the software.
And that lands squarely in the world of DevOps and platform engineering.
For years, the job was to create guardrails around reuse.
Standard stacks.
Approved frameworks.
Blessed pipelines.
The goal was consistency. Not because creativity was bad, but because variance was expensive. Every bespoke implementation increased operational overhead. Every one-off decision multiplied risk. DevOps matured by reducing entropy.
Platform engineering pushed that further. Internal developer platforms abstracted complexity and enforced repeatability. Paved roads scaled better than dirt paths.
That logic remains sound.
But AI-assisted bespoke development changes the terrain.
If developers can generate custom code rapidly, the volume of unique logic will increase. Not recklessly, but naturally. When the cost of writing tailored workflows drops toward zero, teams will optimize for precision instead of approximation.
DevOps historically pushed toward standardization to control complexity. AI pushes toward customization because customization is suddenly cheap.
That tension is real.
The answer is not chaos. It is evolution.
DevOps shifts from policing implementation to governing intent.
Instead of dictating every component, platform teams define constraints. Policies. Interfaces. Security controls. Compliance checks. Observability hooks. Deployment pipelines.
Within those boundaries, AI-generated code can flourish.
If bespoke logic increases, the platform must absorb variability without breaking. That means stronger policy-as-code. Stronger automated testing. Stronger runtime visibility.
Because if code becomes easier to create, it also becomes easier to create poorly.
Craftsmanship matters again.
Not craftsmanship as nostalgia for handwritten loops.
But craftsmanship as disciplined system design.
The best DevOps and platform teams will not resist AI-generated bespoke software. They will design for it. They will assume variation. They will enforce standards at the edges instead of micromanaging the center.
In the component era, control came from sameness.
In the AI era, control may come from observability and policy.
That is a meaningful pivot.
This is not just a tooling shift.
It is a leadership shift.
For the last twenty years, many digital leaders optimized for efficiency through standardization. Buy instead of build. Adopt instead of invent. Stay inside the lines. Reduce variance. Control cost.
That mindset made sense when custom meant slow and expensive.
But if custom becomes fast and affordable, leaders face a new decision.
Do you keep shaping your business to fit the software?
Or do you shape the software to fit the business?
That is not technical. It is strategic.
When bespoke logic becomes cheap, differentiation becomes easier to encode. The unique way you serve customers, manage risk, or create value no longer has to be compromised to match someone else’s abstraction layer.
But speed without discipline is fragility.
The leaders who win in this era will not be the ones who unleash infinite variation. They will be the ones who combine speed with clarity. Intent with governance. Customization with accountability.
Craftsmanship returns.
Not as artisanal coding for its own sake.
But as thoughtful system design aligned to real business outcomes.
The early days of software were messy because we lacked guardrails.
The component era stabilized the industry because we embraced reuse.
The AI era gives us something different. The ability to combine both. Precision without paralysis. Customization without chaos.
That is the full circle.
Earth to earth.
Ashes to ashes.
Dust to dust.
Off-the-shelf software is not disappearing tomorrow. SaaS is not going quietly into the night. But the unquestioned dominance of “buy before you build” is no longer automatic.
We are no longer constrained by the old economics.
When custom is cheap, alignment becomes the priority.
When code can be shaped in minutes, the differentiator is clarity of intent.
That shifts power back to the organization. Back to the operators. Back to leadership.
Because this was never really about syntax or frameworks.
It was about who adapts to whom.
For twenty years, businesses adapted to software.
Now, software can adapt to the business.
That is not a small inversion.
So maybe this is not a funeral.
Maybe it is a eulogy for the assumption that off-the-shelf was always the smarter move.
Dust to dust.
And code to code.
