When Code Remembers What You’re Paid to Forget
By Nigel Dsouza
In a world where infrastructure deploys itself, AI models write our pipelines, and systems monitor our every move, a strange question emerges:
What if your code knew more about you than you did?
Welcome to the age of Severance Engineering —
where our professional systems remember what our personal selves are told to forget.
🧍♂️ The Two Selves of the Modern Engineer
If you’ve seen the show Severance, you know the premise:
A chip in your brain separates your work memories from your personal life.
- The worker self lives entirely in the office.
- The personal self has no idea what happens inside.
Now think about your cloud infrastructure.
You’ve built:
- Pipelines that deploy without you
- Lambda functions that run long after you’ve left
- Security policies written at 2am under pressure
- IAM roles that grant trust you no longer feel
- Terraform plans that haven’t changed in 3 years — but still run daily
Your systems have a memory.
🧠 Code is the Consciousness You Leave Behind
Every line of code is a decision.
Every architecture diagram is a frozen belief.
Every CI/CD pipeline is a philosophy.
And yet — we forget.
We move jobs. We rotate out. We burn out.
We sever.
But the system does not.
🤖 AI is Your Permanent Shadow
With generative AI entering the DevOps lifecycle,
we are no longer just writing the infrastructure —
we are training the next layer of it.
- Every prompt
- Every commit
- Every resolution
...becomes a behavioral artifact.
Your tools remember.
Your assistants autocomplete your legacy.
You’re not writing infrastructure.
You’re writing memory.
🧭 Terraform, Jenkins, and the Archive of You
Think of it:
- Your Terraform modules are maps of your past risk tolerance.
- Your GitHub repo is a forensic mirror.
- Your observability dashboards reflect not just usage — but belief.
In Severance, the outie doesn’t know what the innie does.
In our world, it’s reversed:
The systems remember what the humans suppress.
⚖️ The Ethics of Infrastructure Amnesia
We must ask:
- Who audits our intent when we’re no longer around to explain it?
- Who maintains the mental model when the modeler is gone?
- Should code age out like memories do?
Maybe infrastructure needs a half-life.
Maybe policies should come with expiry dates.
Maybe systems should forget — gracefully.
🧵 Conclusion: Remember With Purpose
In this era, the line between developer and infrastructure is vanishing.
You don’t just write code.
You inscribe identity.
You deploy versions of yourself —
into AWS, into Jenkins, into memory.
So:
- Write wisely
- Comment generously
- Leave breadcrumbs
Because the system will remember.
Even when you’re severed from it.
👤 About the Author
Nigel Dsouza is a Principal Software Engineer at Fidelity Investments.
He writes code with the full knowledge that someday, someone else will live in it —
and maybe, just maybe, try to remember who he was.
Top comments (6)
This was a really thoughtful take. The Severance analogy caught me off guard at first, but the more I read, the more it made sense—especially the idea of our decisions sticking around in infra long after we’ve moved on. It’s something we kind of know, but rarely say out loud. Also really liked the bit about infra not needing to be permanent by default. Subtle but solid perspective. Appreciate you sharing this!
Very interesting thoughts, Nigel!
Who wouldn't want to leave behind a good legacy!
Generative AI may yet prove Shakespeare wrong......not just the evil that programmers do will live after them; the good and the indifferent will too.....
It is a sobering truth that in today’s high-tech world, our AI and automation systems remember everything we create. They do not forget — even when we do. As engineers, we often strive for a healthy work-life balance, separating our personal and professional lives. But once we leave the workplace, we emotionally detach from the systems we’ve built. The problem is: the systems don’t.
Modern AI tools are designed to learn from our behavior. They silently store our past decisions — and even our mistakes — long after we’ve moved on. This brings up serious questions: Who ensures that these systems carry forward the right intent once we’re gone? Should machines, like humans, be allowed to forget?
Today, building a system is like leaving a digital version of yourself behind. And that memory — unedited and permanent — could be misused. The challenge is clear: we must design with care, aware that what we create may outlive us. Whether that’s a gift or a risk… only time will tell.
Thanks for sharing. An interesting read.
Interesting read.
This is hauntingly brilliant, Nigel. The metaphor of Severance fits perfectly — we may mentally clock out, but the systems we build never sleep.