Anthropic Dropped an AI Tool for COBOL, IBM Stock Fell 13%, and I Did a Thing…

Last week, a Reddit post stopped my scroll: “Anthropic just dropped an AI tool for COBOL and IBM stock fell 13%.”

Anthropic announced that Claude Code could modernize legacy COBOL codebases, mapping dependencies, documenting workflows, and surfacing risks that would take human analysts months to find. Wall Street panicked. IBM lost over $31 billion in market cap in a single day. Its worst day in 25 years. Accenture and Cognizant took hits too.

I read all of this as an IBM alumnus who was forced to learn COBOL as a Computer Information Systems student in college.

My reaction was not what you’d expect.

I didn’t panic about mainframes. I didn’t write a hot take about AI disruption. I opened a terminal and started writing COBOL.

Why?

Because I learned to program when I was 14, writing text-based games in line-numbered BASIC on an Apple IIe at my middle school computer lab and a Commodore 64 at home. That’s how a lot of us got hooked. Not from a textbook, but from making the computer do something fun. I wanted to see if COBOL, a language born in 1959, still had that spark. Was it still intuitive to think in? Could you still build something interactive and interesting with it?

And honestly? I was feeling nostalgic. Deep in the back of my head was Apple Trek, a turn-based strategy game where you navigated quadrants, managed energy and torpedoes, and hunted Klingons (later renamed “Klarnons” after the lawyers called). The original was written in Integer BASIC for the Apple II in the late 1970s. I played a port of it on my schools Apple IIe in the late 80s. I wanted that feeling again: text on a screen, decisions to make, consequences to face.

Now, to be clear, I never wrote COBOL professionally. IBM recruited me because I was one of the early adopters of web technologies and the Java language, and I learned their new middleware products called WebSphere. Java, ironically, was positioned as the modern replacement for COBOL in many business applications, but that is a different story. What I did bring from my CIS coursework was a solid and working knowledge of data structures, and COBOL’s approach to defining data turns out to be one of the most interesting things about the language.

I knew a full Apple Trek clone in COBOL was too ambitious for a weekend experiment. But a simpler turn-based adventure? That I could do.

So I Built a Space Debris Tracking Game. In COBOL.

Since I co-founded xOrbita, a space debris detection and collision avoidance company, the theme chose itself. Space Domain Awareness, the real-world challenge of tracking 30,000+ pieces of orbital debris and protecting operational satellites, became the setting for a text-based adventure game.

Here’s the premise:

You’re the operator of SENTINEL-1, a 3U CubeSat in Low Earth Orbit at 550 km, equipped with an optical debris sensor. Three satellites subscribe to your collision warning service:

• WEATHERBIRD-7 (NOAA): polar weather satellite at 520 km
• GLOBALLINK-12 (ESA): communications satellite at 580 km
• TERRAWATCH-3 (JAXA): Earth observation at 510 km

Mission briefing / intro screen showing SENTINEL-1, active debris count, and the subscriber manifest

Over 5 orbital passes, you configure 3D sensor scans (choosing azimuth sector, elevation band, and range), analyze the detected debris objects, compute collision probabilities, decide which subscriber satellite to warn, and recommend an avoidance maneuver. Score points for correct decisions. Lose points when satellites get hit.

Orbital Pass 01 status dashboard showing power, fuel, sensor readiness, subscriber status, and the start of scan configuration

It’s resource management meets space situational awareness, rendered entirely in monospaced text on a terminal screen.

What COBOL Brought to the Table

Here’s what surprised me: COBOL’s data structures are perfect for this kind of simulation.

The satellite table uses COBOL’s hierarchical record layout with OCCURS clauses, essentially a typed struct array with named fields at every level:

01 WS-SATELLITE-TABLE.
   05 WS-SAT OCCURS 3 TIMES.
      10 WS-SAT-NAME        PIC X(16).
      10 WS-SAT-AGENCY      PIC X(12).
      10 WS-SAT-ALTITUDE    PIC 9(4).
      10 WS-SAT-RISK        PIC 9V9(4).
      10 WS-SAT-STATUS      PIC X(10).
         88 SAT-NOMINAL     VALUE "NOMINAL".
         88 SAT-WARNING     VALUE "WARNING".
         88 SAT-CRITICAL    VALUE "CRITICAL".

Those level-88 condition names are one of COBOL’s most elegant features. Instead of writing IF WS-SAT-STATUS = "CRITICAL" everywhere, you just write IF SAT-CRITICAL. Self-documenting code that reads like English. In 1959. We reinvented this concept as enums decades later.

Coming from Java, where you’d define a Satellite class with getters, setters, and an enum for status, COBOL’s approach feels both ancient and refreshingly direct. You declare what the data looks like. You give every field a name. You define what valid states mean. No boilerplate. No abstraction layers. Just structure.

The game logic reads just as naturally. Here’s how random orbital events are handled each turn, using COBOL’s EVALUATE TRUE, which is its version of pattern matching:

3200-RANSOM-EVENT
    MOVE FUNCTION RANDOM TO WS-EVENT-ROLL

    EVALUATE TRUE
        WHEN WS-EVENT-ROLL < 0.15
            DISPLAY "  ** SOLAR FLARE DETECTED **"
            DISPLAY "  Sensor interference! Power draw +5%"
            SUBTRACT 5 FROM WS-CUBE-POWER
        WHEN WS-EVENT-ROLL < 0.25
            DISPLAY "  ** GROUND STATION UPDATE **"
            DISPLAY "  Debris catalog updated with 47 new objects."
            ADD 47 TO WS-TOTAL-DEBRIS
        WHEN WS-EVENT-ROLL < 0.35
            DISPLAY "  ** BATTERY RECHARGE **"
            DISPLAY "  Passing through sunlight. Power +10%"
            ADD 10 TO WS-CUBE-POWER
        WHEN OTHER
            DISPLAY "  Systems nominal. No events detected."
    END-EVALUATE

EVALUATE TRUE checks each WHEN condition top to bottom and executes the first one that's true. No fall-through. No break statements. ADD 47 TO WS-TOTAL-DEBRIS. SUBTRACT 5 FROM WS-CUBE-POWER. The code reads like mission procedures because that's exactly what COBOL was designed to produce.

Scan results showing 8 detected debris objects with azimuth, elevation, range, velocity, and size columns, followed by collision probability computation and the operator decision prompt

The game uses PERFORM VARYING loops for table iteration, COMPUTE for collision probability math, and FUNCTION RANDOM for procedural debris generation. Every scan produces a different debris field. Every turn has random events: solar flares that drain power, ground station updates that add to the debris catalog, battery recharges when passing through sunlight.

The Verdict: Still Relevant?

Writing this game reminded me that COBOL wasn’t designed to be clever. It was designed to be clear. The language forces you to declare your data structures up front, name everything explicitly, and write logic that reads like a business procedure. There’s a reason it survived 67 years and still processes an estimated 95% of ATM transactions in the United States.

Is it the language I’d choose for a startup in 2026? NO. But “relevant” isn’t just about what’s trendy. COBOL is relevant because hundreds of billions of lines of it are running right now, handling your money, your flights, and your government services. Understanding it, even through something as silly as a space debris game, matters.

Mission Complete final report showing ELITE OPERATOR rating with 875 points, zero collisions, and “NASA wants your number”

What’s Next

The game compiles clean on GnuCOBOL (free, open source, runs on Mac/Linux/Windows) and also runs on JDoodle’s online COBOL compiler if you want to try it in a browser. I may keep building on it, adding more orbital mechanics, expanding the debris catalog, maybe even implementing a simplified Kessler syndrome scenario where collisions create more debris. The Apple Trek dream isn’t dead, just deferred.

If you want to try it, the source code is available https://github.com/jhavera/cubesat-game.git. Compile on Mac with:

brew install gnucobol
cobc -x -free -o cubesat-game cubesat-game.cob
./cubesat-game

And if you’re one of the greybeards who remembers COBOL from the mainframe days, or a student who thinks it’s irrelevant, fire it up. You might be surprised how natural it still feels.

I’m the co-founder of xOrbita, where we’re building the AI-powered eyes in orbit that see what no one else can, delivering intelligence-first space domain awareness that turns real-time detection into actionable collision avoidance. The game is fictional. The debris problem is very real.

COBOL #SpaceDebris #IBM #Anthropic #AI #SpaceDomainAwareness #LegacyCode #xOrbita #Programming #Nostalgia