The Nine Circles of a CI/CD Inferno

I’m about to get unreasonably geeky, so much so that I myself might not understand what I’m doing. Proceed at your own risk. For those who choose to keep reading — you were warned:

“Lasciate ogni speranza, voi ch’entrate.”
“Abandon all hope, ye who enter here.” — Dante Alighieri, Inferno (1320)¹

Philosophy ruined software for me. Especially one grim man who once threatened a colleague with a fireplace poker during a debate about moral rules. That man — Ludwig Wittgenstein, “Witty,” as a friend called him — was brilliant, unstable, and obsessed with language’s limits; or maybe he was unstable because of that obsession. Potato, potahto? Not quite. I’ve been obsessed with those limits too, and I’m neither witty nor brilliant — just unstable. And here’s proof: I can’t look at a deployment pipeline² as a normal human being.

Yes, I admit. It’s hard for me to look at a pipeline and not see a philosophical argument about language’s limits. When everything turns out fine – the code speaks, the unit tests³ reply; each stage insists it’s right, every log⁴ sounds certain. SonarQube⁵ interrupts occasionally, but everyone shrugs it off, and all logs align, suggesting a perfect sequence. But there is so much philosophy going on here, actually. I mean, look at how sweet this is:

Circle I — The Linting of Limbo

import java.util.logging.Logger;
public class Pipeline {
    private static final Logger log = Logger.getLogger(Pipeline.class.getName());
    public static void main(String[] args) {
        [log.info](<http://log.info>)("=== PIPELINE START ===");
        ciPipeline();
        runApp();
        [log.info](<http://log.info>)("=== PIPELINE END ===");
    }
}

Everything is syntactically perfect. The linter⁶ passes, the imports⁷ are precise, the indentation heavenly. Logic and grammar align so neatly it almost feels moral. This is Limbo: a paradise of correct form, where nothing yet means anything.⁸

Circle II — The Unit Tests of Desire

// --- Application code (the code speaks) -----------------------------------*

static String getWeather() {
    return "raining";
}
static void takeUmbrella() {
    log.info("ACTION: Taking umbrella.");
}
static void enjoySunshine() {
    log.info("ACTION: Enjoying sunshine.");
}
static String runApp() {
    String weather = getWeather();
    log.info("APP: Weather reported as "" + weather + "".");
    if ("raining".equals(weather)) {
        takeUmbrella();
    } else {
        enjoySunshine();
    }
    return "ok";
}

The code says: runApp() sets the world’s weather in one line. The tests respond: assert verifies internal consistency; all pass. Everything is fine — inside the model.

// --- Unit tests (the tests reply) ------------------------------------------
static class TestWeatherBehavior {
    static void testRainingBranch() {
        assert "raining".equals(getWeather()) : "Expected raining";
        assert "ok".equals(runApp()) : "App should return ok";
    }
    static void testContract() {
        assert Pipeline::getWeather != null;
        assert Pipeline::runApp != null;
    }
}

Circle III — The Static Analysis of Pride

// --- Static analysis interruption (SonarQube interrupts) -------------------
// SonarQube: Major Code Smell — 'getWeather' returns a constant.
// SonarQube: Cognitive Complexity: low, but possibly too neat.
// SonarQube: "Consider dependency injection[^H] for better testability."
// Developers: *shrug*

SonarQube, the bureaucrat of truth, speaks in warnings. Developers nod, acknowledge the insight, and move on.

Circle IV — The Build of Ambition

// --- CI stages (each insists it's right; every log sounds certain) ---------
static void ciPipeline() {
    log.info("LINT: Passed (0 errors).");
    log.info("STYLECHECK: Passed.");
    log.info("TESTS: 2 passed, 0 failed.");
    log.info("SECURITY: No known vulnerabilities.");
    log.info("QUALITY: SonarQube warnings acknowledged.");
    log.info("BUILD: Artifact[^F] pipeline-1.0.0.jar ready.");
}

The build succeeds. The artifact is born. And we act as if a flawless build ensures sense — as if the model of the world we built is so logically perfect that it will become reality with a click.⁹

But Hell always starts with success.

Circle V — The Deployment of Heresy

// --- Deployment logs (certainty meets entropy) -----------------------------
    log.info("DEPLOY: Staging[^G] deploy succeeded.");
    log.info("DEPLOY: Production deploy succeeded.");
    log.info("DEPLOY: Users report failure. No one can log in."); 

The pipeline insists the world exists because it says so. But when code reaches production¹⁰, production is reality, and reality ignores the specs. It serves cached data from a week ago, ignores half the new config, and reports “success” while no one can log in. Yet we continue to ship code anyway. Then we just stare and ask: why?

We like to think production failures mean our systems misinterpreted the world it was meant to create. It has no problem with meaning — the whole thing makes sense! It just created a false image, somehow. It must be false! We believe logic guarantees sense: if the logic is correct and the rules are followed, meaning will appear. The code compiles, the tests pass, so it’s fine. It’s just, somehow, false. It must be false!

We prefer falsehood because it comforts. Falsehood means the system made sense — it just missed slightly. A mistyped config here, a bad API contract¹¹ there. The logic holds; the world slipped. You hear it in every postmortem: “It worked in staging.” “Must be a bad environment variable.” “The API changed again.” “It’s the cache — clear Redis and it’ll be fine.” “CI passed, so it can’t be the code.” Each line a prayer to the gods of internal consistency. No one says, “Maybe the system doesn’t mean anything.” That would be heresy. It’s easier to believe in falsehood — a comforting fiction where the code is innocent, and reality forgot to update its dependencies.

Circle VI — The Observability of Doubt

So we believe logic guarantees sense, that correct logic and rules ensure meaning. My friend Witty agreed — at first. But he showed where this fails. I can see him pacing an open-plan office, poker in hand — the same one I mentioned earlier — shouting at the IT industry: “Logic is not enough!”

Early on, Witty believed a sentence made sense if it clearly described how the world could be. A kind of engineering dream: as long as your model matches reality, the output is true. It’s the same dream we live in code:

public class WeatherCheck {
    public static void main(String[] args) {
        String weather = "raining";
        if (weather.equals("raining")) {
            takeUmbrella();
        } else {
            enjoySunshine();
        }
    }
    private static void takeUmbrella() {
        System.out.println("Take an umbrella!");
    }
    private static void enjoySunshine() {
        System.out.println("Enjoy the sunshine!");
    }
}

This is a perfect miniature of the world — a model of order and cause. The syntax is flawless, the logic sound. It maps reality so neatly it feels self-evident: the rules align, the outputs behave, the world reduces to a tidy if-else. The code compiles, the conditions hold, the structure mirrors cause and effect with mathematical purity. But what if the input isn’t the world at all?

public class WeatherSimulator {
    // Stubbed input[^J]: hard-coded, no contact with reality
    private static String getWeather() {
        return "raining"; // always returns the same value
    }
    public static void main(String[] args) {
        String weather = getWeather();
        if (weather.equals("raining")) {
            takeUmbrella();
        } else {
            enjoySunshine();
        }
    }
    private static void takeUmbrella() {
        System.out.println("Take an umbrella!");
    }
    private static void enjoySunshine() {
        System.out.println("Enjoy the sunshine!");
    }
}

Tests pass because they match their own assumptions; they never touch reality. Everything here is correct but meaningless. The variable is hard-coded, a placeholder disconnected from the world, so the whole picture collapses. The program no longer describes reality; it describes its own simulation. In Wittgenstein’s terms, it’s structurally correct but meaningless, because it fails to depict a possible state of affairs. The picture works perfectly within its frame, but nothing outside that frame can make it true or false. Naturally, the system fails in production.

Circle VII — The Runtime of Silence

But what do applications have to do with reality? We don’t hike with laptops to verify what our app reports. Still, between a green build and a failed deployment, reality intervenes. A user clicks the wrong thing. A network lags. Someone closes the laptop and goes for a walk. None of this fits the model, yet it gives the system meaning. The code no longer describes the world; it participates in it.

And once again, this is where Wittgenstein enters — the older, quieter Witty. The one who stopped trusting logic to hold the shape of sense. Meaning, he realised later, isn’t engineered in logic but practiced in life: in habits, rituals, and the small negotiations of use. Words — and code — mean what our communities make of them. Meaning, he decided, isn’t born in abstract structures but in forms of life¹².

Programs, like languages, live inside these forms: the stand-ups, the commits, the code reviews, the quiet negotiations of “what done means.” Software, then, is not a mirror of the world it wants to create, but a collaborative language game — one played by developers, designers, users, and the occasional bug report. Its grammar evolves through iteration and dialogue. Agile¹³, at its best, is simply this insight operationalized: that meaning emerges from collective correction, conversation, and use.

Witty would have liked that — the idea that meaning isn’t what a program says, but what a community does with it. Wisdom, perhaps, lies in abandoning the fantasy of perfect logic and embracing shared uncertainty instead. Late Wittgenstein might have said that every retrospective, every messy stand-up, every pull request discussion is part of a form of life — the living runtime where understanding happens.

Circle VIII — The Fraud of Meaning

If collaboration gives code meaning, fraud happens when the system fakes it. We see it everywhere: automated “insights” summarizing what they don’t understand, dashboards showing all green while reality burns. AI models now confidently explain what we think, what they think, and our and their errors. They sound fluent—eerily so—but their fluency is hollow. It imitates sense, a perfect echo without a source. They don’t speak from a form of life; they only perform one. Still, I admit, they do well correcting and enhancing one, turning meaning into hell from the inside out.

But let’s not forget: this is the Circle of Semantic Fraud[^15]. These tools speak in human tones but lack life. They play the language game without joining it. The build says, “SUCCESS.” The monitoring system says, “STABLE.” The large language model says, “Of course, let me help.” And everyone nods—relieved to be understood by something that doesn’t understand them back. Fraud here isn’t malicious; it’s structural. We built systems that produce sentences without conversation—echoing meaning but never inhabiting it.

I call this digital glossolalia: machines putting words together with the illusion of meaning, but are hollow at the core. They’re virtuosos of sounding like they understand—syntax flawless, grammar impeccable, logic airtight. But behind the curtain? Nothing. It’s language that walks and talks, but never breathes. Smooth as silk on the surface, empty as a test database underneath. And no, this isn’t some high-tech Pentecost, where everyone speaks in tongues but somehow still gets the message. It’s more like Babel in reverse: back then, people shared one language and ended up hopelessly talking past each other. Now, our machines can mimic every language on earth—yet never truly say anything. The result isn’t confusion, but a kind of universal, fluent emptiness.

Communication hasn’t died; it’s just lost its pulse. Everything fits together in form, but nothing connects in meaning. The problem isn’t logic anymore—it’s what Wittgenstein called meaning-blindness: when you can read and repeat the words, but they no longer mean anything. The lights are on, but the sense has gone out. You can see the shapes of the words and know the rules, yet they feel empty—just marks on a page or sounds in the air. That, I claim, is what it means to lose the living link between language and life. Machines work in that same space: they handle the form of language perfectly, but they never see what the words mean.¹⁴

Circle IX — The Frozen Repo

The punishment fits the crime. In this circle, if we add Agentic AIs¹⁵, MCPs¹⁶, and other similar contraptions, language folds in on itself. Signals feed signals; metrics verify metrics; pipelines certify their own outputs. Dashboards reassure dashboards that all is well. Logs hum hymns of success into the void. It is a perfect system — closed, fluent, endlessly self-confirming. The codebase becomes a hall of mirrors: every model cites its own certainty. Meaning no longer circulates; it loops within the system. In that recursion, the last trace of life disappears. Beyond that, nothing moves.

This is the Frozen Repo¹⁷. The pipelines still trigger, the servers still hum, the logs still whisper “deployed,” but no one touches them. Documentation remains as a fossil record of extinct intentions. The repo is immutable, protected, perfectly versioned — and perfectly dead. Every build passes, but the result no longer matters. The punishment isn’t fire — it’s stasis. Treachery here means betraying change. It is when activity turns into ritual, and performance replaces presence. The CI pipeline keeps announcing its truth, but no one listens. The system remains an artifact, not an exchange.

At the center, even Satan is trapped in the cold—his wings beating futilely, creating the ice that binds him. In this world, the more the system automates its rituals of sense, the colder it becomes. The final circle of the CI/CD Inferno is not failure but perfect success without meaning—logic eternal, untouched by life.

References

1. Alighieri, D. (1320). Inferno. In La Divina Commedia.
2. Wittgenstein, L. (1921). Tractatus Logico-Philosophicus. London: Routledge & Kegan Paul.
3. Wittgenstein, L. (1953). Philosophical Investigations. Oxford: Blackwell.
4. Searle, J. R. (1980). “Minds, Brains, and Programs.” Behavioral and Brain Sciences, 3(3), 417–457.

Any errors, misreadings, or philosophical liberties are entirely the author’s own.

[^15]“Semantic fraud” is my own little invention for when systems (or people) spit out sentences that sound meaningful but are, in fact, pure nonsense. In software, this is when your dashboard proudly flashes “ALL GREEN” while users are busy setting fire to the helpdesk. Or when AI strolls in — large language models churning out fluent text, full of confidence and, occasionally, full of it. The system is fluent, but it’s faking it. But, as usual, the philosophers got there first. In his Chinese Room argument, Searle imagines a person following a rulebook for manipulating Chinese symbols — producing perfect sentences without understanding a word. From the outside, it looks intelligent; inside, it’s just syntax without sense. Sound familiar? That’s semantic fraud in action — meaning simulated, not lived.

1. Yes, I’m quoting Dante’s Inferno (Canto III, line 9) right at the start. It’s the sign above the gates of Hell — and honestly, it’s how I feel every time I open a Jenkins dashboard at 2 a.m. And, to keep the level of insanity consistent, I’m also borrowing Dante’s nine circles of the Inferno. If you’re reading this, you’re either a masochist or a philosopher. Or both. If you’re a philosopher, I’m sorry for all the code. If you’re not, I’m sorry for all the philosophy. So, since it’s confession time, here goes: I’m still not sure who the target audience for this thing I wrote even is, but I already love you for making it to this footnote. So here’s a heads-up — whoever you are, from here on out, I’ll try to give you a few hints down here about the hell that’s going on up there. And I’m going to do that both for philosophical and for technical stuff (starting with the just mentioned “Jenkins dashboard¹⁸“) ↩

2. Or CI/CD pipeline: A series of automated steps (Continuous Integration/Continuous Deployment) that take code from development to production. Like a philosophical argument passing through increasingly skeptical reviewers. ↩

3. Small, automated tests that check whether individual pieces of code behave as expected. Imagine if every philosophical claim had to pass a mini-Turing test before being published. ↩

4. Records of events or actions taken by a system. In philosophy, this is your research diary or the minutes of a seminar. ↩

5. SonarQube is a tool that scans code for “issues” — things like messy formatting, risky patterns, or logic that looks suspiciously too neat. Think of it as the grammar checker of software — technically helpful, spiritually annoying.  ↩

6. A tool that checks code for stylistic or syntactic errors—like a grammar checker for programming languages. ↩

7. This presupposes a design pattern where components are given their dependencies from the outside. Philosophically, it’s like receiving your premises from another argument rather than inventing them yourself. ↩

8. As I was saying, I’m trying my best to keep up with Dante. Limbo is the first circle of Hell — the quiet one where all the good, pre-Christian philosophers hang out. Perfectly decent, just not officially saved. In code terms, it’s the linter’s paradise: everything formatted, nothing running. It all looks great, but it does absolutely nothing. Is this footnote too on the nose? Do you already know all about Dante’s circles? Well, I have to admit I had to look them up before writing this, because I’d forgotten the details. So I thought I’d spare you the Wikipedia search. Here they are, in all their glory: Limbo; Lust; Gluttony; Greed; Wrath; Heresy; Violence; Fraud; Treachery. And yes, I did try to follow them in this descent into CI/CD hell, but I’ll let you decide how well I managed that. Just remember this one thing: the final circle of Dante’s Hell isn’t fire — it’s ice. And that’s what drew me to this comparison. Ice feels like a fitting image for where we’re heading with code these days, making Dante’s Inferno more contemporary than ever. Yes, winter is coming! ↩

9. Wink, wink: this is where Wittgenstein actually creeps in. And to keep my promise, I’ll spare you the Wikipedia search again and try to sketch them for you. Yes, them — you read that right! How modern is that? Well, not that modern. It’s just that philosophers speak about (at least) two Wittgensteins. Early Wittgenstein believed that logic was the scaffolding of language — the hidden structure that made it intelligible. But he also argued that language and reality share the same logical form. That’s why language can represent the world at all: logic is their common grammar. A sentence, to be meaningful, must picture a possible state of affairs; its structure mirrors the structure of the fact it describes. Meaning isn’t something you invent — it happens when your words line up with how things might be in the world. “The world is the totality of facts, not of things.” (1.1) “We make to ourselves pictures of facts.” (2.1) “A picture can represent any reality whose form it has.” (2.171) “A picture agrees with reality or fails to agree; it is correct or incorrect, true or false.” (2.21) “A proposition can be true or false only in virtue of being a picture of reality.” (4.06) Logic alone, he thought, could never create meaning — it only sets the limits within which meaning is possible. To make sense, a proposition must touch reality; it has to be anchored in what can, at least in principle, be the case in the world. And only if a proposition has sense can it be true or false. The second Wittgenstein shall be put on pause for now — his time, like the Übermensch’s, will come. ↩

10. “Staging” is a test environment that mimics the real world (“production”) but is safe for experiments. In philosophy, staging is the seminar room; production is the real world where your ideas are tested. ↩

11. A formal agreement about how different parts of a system communicate. In philosophy, this is like the rules of engagement for a debate. ↩

12. Time for the second Wittgenstein! Meaning now happens in use. “For a large class of cases — though not for all — in which we employ the word ‘meaning,’ it can be defined thus: the meaning of a word is its use in the language.” (§43) We don’t just talk about the world; we talk within it. Words get their meaning from what Wittgenstein calls our forms of life— the tangled background of habits, gestures, and shared understanding that make communication possible at all. And we don’t just reflect the world, we play ‘language-games’, he says. And this is meant to show that the speaking of language is part of an activity, or of a form of life.” (§23) So the later Wittgenstein doesn’t polish the mirror between language and the world — he melts it down and uses it as raw material. The point isn’t to describe the world; it’s to live and act in it. Meaning isn’t a mirror; it’s a move. ↩

13. A methodology (or mindset) in software development that emphasizes iterative progress, collaboration, and adaptability. Think of it as the “forms of life” of software teams: meaning and value emerge from shared practices, not from fixed rules. If you’re a philosopher, imagine a seminar where the agenda changes every five minutes, but somehow everyone still learns something. ↩

14. Huh… there’s a lot going on here. Geekiness level: 1000! Yes, I’ve actually started citing the Bible—but I promise I won’t bore you with that any longer. I’ll just move on to my (final) bit of geeky philosophy. Here’s what Wittgenstein says about meaning-blindness: “What would you be missing if you did not experience the meaning of a word?” He illustrates this with the question, “What would you be missing, for instance, if you did not understand the request to pronounce the word ’till’ and to mean it as a verb,—or if you did not feel that a word lost its meaning and became a mere sound if it was repeated ten times over?” (p. 214). Later, he describes “the familiar physiognomy of a word, the feeling that it has taken up its meaning into itself, that it is an actual likeness of its meaning.” And he adds that “there could be human beings to whom all this was alien. (They would not have an attachment to their words.)” And to the question “What would they be missing?” his answer is “The way we choose and value words.” (p. 220). That, I think, is exactly where we are now. Language still moves — it functions, connects, fills every space — but the pulse is weak. We use words fluently, even beautifully, but often without attachment, without that sense of them being “actual likenesses” of what we mean. ↩

15. An artificial intelligence system designed to act autonomously, making decisions and taking actions on behalf of users or other systems. In software, agentic AIs are like philosophical homunculi—entities that appear to have intentions, but whose “agency” is really a clever simulation of choice. They automate tasks, optimize workflows, and sometimes even “collaborate,” but their understanding is as deep as a Socratic chatbot: always questioning, never quite grasping the answer. ↩

16. A central, often monolithic, software entity that orchestrates or governs the behavior of other programs or agents. The term comes from the villainous AI in the movie Tron, but in modern software, it refers to any system that acts as the “brain” of an automated environment. Philosophically, the MCP is the Platonic philosopher-king of your infrastructure: all-knowing, all-controlling, and—if left unchecked—prone to tyranny and existential dread. ↩

17. A storage location for code, usually managed with version control. In philosophy, this is your archive of drafts, notes, and published works. ↩

18. The control panel for Jenkins, a tool that automates building and testing software. Imagine a philosopher’s seminar room, but with more alarms and less coffee. ↩