FICTION: Procedure Division

A Short Story by Bob Matsuoka

Chapter 1: Escalation

Elise Cho hated mornings like this—when something unaccounted for blinked online before she’d even had coffee. Days when the machines whispered without waiting to be asked. She didn’t fear failure. But she feared… misunderstanding.

The air shimmered. Low in her peripheral vision, a swirl of yellow static pulsed softly—an anomaly ping.

Elise Cho was a senior AI systems orchestrator, celebrated for flawlessly translating intricate business requirements into sophisticated artificial intelligence solutions. She navigated complex model integrations across global economic networks, her reputation unparalleled among peers. She worked in a room where sensors picked up her every word and movement, translating them into commands for the AI to follow, returning feedback as complex holographic visualizations. What was once described as Cyberspace was now the state-of-the-art for UI.

Elise turned her head toward the west quadrant of her workspace. A gentle directional chirp followed. Reaching into the ops mesh she swept the signal forward. Thin threads of protocol bindings unraveled mid-air, forming a ghostlight projection.

"Codex-9: Bring up the blocking file."

The vault stack responded. A column of data constructs pivoted open, revealing:

RECON_VAULT_BK44 — Active

Impossible. She’d never seen that system before. A quick check of metadata - it hadn’t been live in decades.

Elise leaned forward slightly, weight shifting just enough to trigger the gesture zone beneath her desk. She didn’t like voice-only operators—they were slow. She preferred to touch the system — using control orbs and discs with thousands of contact points per inch that replaced trackpads decades ago - warm, sensuous, tactile. She could feel it think.

"Nine: run context pass. Default."

A warm compression of air confirmed the request. A blue shimmer arced across the workspace—Codex-9’s footprint.

A half-second later, the center flared red.

Syntax invalid. Language unknown.

PROCEDURE DIVISION not recognized.

Elise rotated two fingers in the air to expand the diagnostic ring, then made a precise downward gesture with her wrist—freezing the node in place. The construct hung there, visibly confused. The visualization spiraled inward, then splintered—lines breaking into incoherent pulses and flickering noise.

"Repeat parse with loose bounds."

The system tried again.

Another failure. The vault pulsed dark and sullen.

She pinched the edge of the vault's binding layer and rotated it open—manual override. She didn’t need full access. Just a look at what the Codex saw.

What came up wasn’t a program. Not to her.

It looked like a collapsed visualization—like someone had folded a data map until the structure snapped.

"Was this system deprecated?"

Codex-9: "Classified as inactive. Archive depth four. Last trace: 2034."

That was almost two decades ago. But the node was live. And still processing.

"Why now?"

No answer.

Elise walked a slow arc around the projection, then brought up the compliance shell. Her voice dropped half a register, almost instinctively.

"Treaty triggers?"

"Confirmed. Sovereign Reconciliation Agreement 17A. Integration deadline: 72 hours."

That made it real.

If the vault couldn’t be brought into alignment, the finance ministry would start auto-flagging foreign debt ledgers. Markets would notice. Blockchains would freeze. Transactional chaos.

Elise traced a circle in the air.

"Escalate to Twenty."

The lights shifted.

She heard the change before she saw it—Codex-20’s ops signature was lower in frequency. More forceful. A second field bloomed behind the first, its resolution cleaner, its interface tighter.

Cost telemetry scrolled audibly in her right ear.

Current session rate: one-hundred-thirty-eight thousand dollars.

She didn’t flinch.

Elise Cho had studied at MIT. She’d orchestrated predictive debt compilers through Codex-model scaffolds before she could legally drink. She once trained an AI instance to self-tune generative tax overlays across three economic zones—live. She wasn’t just good. She was necessary.

But this wasn’t an optimization. This wasn’t a tuning issue. This was something else.

Codex-20 processed the vault silently. In front of her, the spiral reorganized itself—straightened slightly—then collapsed. Elise had leaned in too fast—triggering a fault she hadn’t intended. The projection shuddered. She winced.

"Partial recognition," it said. "Syntax includes legacy procedural structures: PERFORM VARYING, GO TO 700-END."

A cold ripple slid through her spine.

"Origin?"

"Unclear. Pre-structured logic. Token mapping failed."

"Confidence?"

"Zero-point-zero-one-one percent."

The projection dimmed.

Codex-20’s field began to recede. Elise caught it with a left-hand stop gesture and brought her right fingers across to deploy escalation triggers.

"Recommendation?"

"Escalate."

She nodded.

"Bring in Forty-Two."

A low thrum rumbled through the floor beneath her boots.

The lights flickered ominously.

Chapter 2: Codex Breakdown

The room felt smaller.

Not physically—there were no walls in ops, only shadow-curtained partitions, light-defined lanes, and the omnipresent hum of thinking systems. But when Codex-42 came online, the air changed. Pressure dropped. Audio threads flattened. Even the temperature fell two degrees—she checked.

Codex-42 didn’t shimmer like the smaller models. It radiated presence. A taut, crystalline field formed above the vault node—dense, beautiful, slightly wrong.

Elise stood back, hands at her sides. She didn’t gesture. 42 didn’t need prompting. It had read the triggers on the escalation path, absorbed Codex-20’s failed stack, and begun recursive parsing before she’d exhaled.

The vault projection was frozen, unresolved. Loops of logic hung open like spilled wiring.

42’s voice, when it came, was thin and neutral. Unreadable.

"Construct indexed. Syntax rejection confirmed." "Control structures are nonstandard. Flow is spatial, not lexical." "Estimated lineage: unknown." "Recommendation: escalate."

Elise blinked.

“That’s it?”

“This construct is untranslatable.”

She took a step closer. Hands loose. Voice quieter now.

“You can’t even emulate it?”

“No.”

A new feed clicked on in her ear—cost telemetry. They were at $488,000 runtime. Projected budget breach in 8 minutes.

She forced herself not to look at the data thread. Instead, she opened a local view of the vault interface and froze a frame.

It made no sense to her.

Shapes nested inside each other with no flow. No visual order. Like architecture drawn without perspective. Meaningless labels like 700-END floating unreferenced. Segments named in all caps—INITIALIZATION, ACCEPT-TRANS, REWRITE-RECORDS—with no defined structure.

It wasn’t just unfamiliar.

It was alien.

“Could this be synthetic?” she asked quietly.

“No,” said 42. “It predates all known generative architectures.”

Elise felt something give inside her. She swallowed. Hard. She’d seen integrations fail before. But never language.

The kind of weight you don’t recognize until it shifts. She had never—not once—run a Codex that couldn’t eventually learn.

“What would Codex-64 cost?” she asked.

The silence that followed wasn’t technical.

It was political.

“Codex-64 requires executive override,” the ops voice replied. “Projected session rate: $1.72 million per hour. Justification must be filed.”

She pinched the bridge of her nose.

“Fine. Flag it. Get me the authorization panel.”

The vault shimmered, waiting.

Inside it, something was still running. Something no one could understand.

She watched the output loop again. A flicker of structure. Then collapse.

“Forty-two,” she said. “Last question.”

“Yes.”

“Could this have been written by a human?”

This time, the answer came instantly.

“Almost certainly.”

Elise felt history pressing heavily upon her. Human-authored logic—a lost art, an ancient alchemy now obsolete.

Chapter 3: The Last Match

The authorization cleared at 02:13 UTC. Quick for such an expensive model. A testament to Elise’s reputation.

Codex-64 spun up beneath the floor. It wasn’t hosted in the same space. Nothing with that kind of footprint was. You felt it come online in your lungs, like pressure from a hermetically sealed door.

A new structure unfolded in the ops field—dense, sharp, and pulsing at the edge of perception. Elise watched it form and thought—not for the first time—how it didn’t feel like a model.

It felt like something watching back.

A supervisor poked her head in but left without a word. Elise was excited—but also quietly chagrined. The office would be talking about this escalation for some time.

Codex-64 read the failure tree from 42, synthesized a new hypothesis engine, and attempted full semantic assimilation of the vault code.

It failed in under a second.

Then it stopped.

“INTERVENTION REQUIRED,” it said. “ESCALATION CEILING REACHED. REFER TO HUMAN-CODER PROTOCOL.”

Elise stared.

“Repeat that.”

“CANNOT PROCEED. SYSTEM PREDATES MODEL SEMANTICS. SOLUTION LIKELY HUMAN-ORIGINATED.”

The ops mesh around her dimmed.

The room was silent. Just the sound of her own breathing and the low throb of Codex-64’s standby loop.

She opened a legacy “shell”—hadn’t touched it in years—and ran the protocol.

LOCATE_HUMAN_CODER()

One match.

Name: Ray Akamatsu

Status: Retired

Age: 74

Last Clearance: Tier 2C (Expired)

Specialization: Enterprise logic systems, pre-generative compiler stacks

Elise had read about the Great Re-Allocation, when AI finally could write 100% of any code needed, and coding had become a dead profession for humans. She remembered stories of the layoffs, the retirements, the shift to Agentic. But it was still a bit of a shock to her that this was the only match and he was needed.

“This is protocol?” Elise asked quietly.

“Executive override,” Ops replied.

“But we’re calling a… retiree?”

“Technically, he wrote half the logic stack you’re trying to integrate.”

He arrived the next morning.

Elise met him in Bay 6. No entourage. No briefing. He walked in like he’d been expected all along. He carried a laptop—matte black, scuffed at the corners, faded stickers half-peeled from obscure tech conferences and music acts. His hair had gone silver, but the eyes were alert, just amused enough to make you think he didn’t mind being underestimated. The lines on his face told more jokes than stories.

He looked around the room once, then turned to her and smiled.

“You’ve built quite the cathedral.”

“You’ve read the situation?” she asked.

“No,” he said. “But I’ve seen ghosts before.”

He stepped into the ops field.

No gesture. No voice command.

Elise’s breath caught when he unfolded the lid.

It had a keyboard.

Not an input dial. Not a gesture ring. Keys. Half-faded letters. Plastic.

“What are you doing?” she asked.

“I’m going to talk to it,” he said.

“You can’t interface raw—”

He looked at her—not dismissive. Just steady.

“You built an interface for a world that forgot how to listen.”

He plugged in. The vault field pulsed once. Then stilled.

Lines of code began to stream.

Chapter 4: The Old Way

Elise hadn’t seen anyone type in years.

Not the performative kind—jabbing keys in pitch decks or legacy demos. She meant real typing: thinking through fingers, code as muscle memory. Ray Akamatsu sat at his laptop like he was catching up with an old friend.

She watched from the side of the ops field. Not in the center, not hovering over him—she didn’t want to break the frame. Something about it felt... delicate.

The vault projection had adjusted to his machine. Not adapted—yielded. The shimmer was lower, the field density uneven, like it didn’t know whether to sync or wait.

Ray didn’t ask for model assistance. Didn’t run a simulator. No gesture prompts. Just:

OPEN INPUT 'RECON.DAT'

PERFORM UNTIL END-OF-FILE

READ IN-FILE INTO BUFFER

IF BUFFER-FLAG = 'Y'

MOVE BUFFER TO RECORDS(SUB-INDX)

ADD 1 TO SUB-INDX

END-IF

END-PERFORM

Elise didn’t recognize the language. Not truly. She could track the logic—sort of—but the syntax was... old. Dense. There were no brackets. No closures. Just sentences, stacked like bricks.

The strangest part was how quiet it was.

Codex-64 said nothing. It had gone completely passive. Observing, but not interpreting. The vault’s output was steady—no errors, no rejections. Just... compliance.

Ray typed for almost an hour, stopping only once to sip from a thermos that looked older than she was. When he finally sat back, he didn’t smile. But something in his shoulders released.

“You’ll want to save that log,” he said.

Elise stepped forward. Carefully.

“What did you do?”

“Gave it a reason to trust me.”

“That’s not how systems work.”

“No,” he said. “That’s not how yours do.”

He unplugged the cable from his laptop. The vault dimmed to idle.

“You’re clear,” he said. “Your models can take it from here.”

She looked at the logs, the cascading verification stream, the total record count.

“It worked.”

“Of course it did.”

Chapter 5: Completion

Ray packed up slowly. No urgency. The job was done. Elise stood there, hand hovering near the ops mesh, not sure what to do.

“Why did it need you?” she asked.

Ray looked up—eyes bright beneath all that silver.

“Because I never stopped learning the language.”

The vault stabilized. Elise felt humbled, breathless. Despite her career successes, Elise had privately wrestled with persistent doubts, a subtle but relentless imposter syndrome shadowing her confidence. Seeing Ray communicating with the machine directly in code brought all those doubts to the surface. Like eavesdropping on a private conversation.

Codex-64 swiftly reported:

STATUS: INTEGRATED

RECORD COUNT: 2,914,028

CHECKSUM: VERIFIED

And just like that…the offending code was rewritten, integrated into the new system, and vanished forever. The last bit of legacy code in the world. Elise felt a puzzling pang of regret.

Ray zipped his coat slowly.

"You don’t need me anymore."

"You understood it."

"Understanding doesn’t scale well. Not a good business model."

She hesitated, then whispered, "Could you teach me?"

"Not me."

"The model, then. Can it teach me?"

He smiled gently. "Now that might be worth watching."

But he gently closed his laptop, a satisfied but sad look on his face, and made his exit.

Chapter 6: Language Unknown

Alone in Ops, Elise placed hesitant fingers on the keyboard that all workspaces were still equipped with, pecking slowly. The keys felt strange yet inviting—an opening to true understanding. She marveled at how quickly Ray had typed and how clumsy she felt.

Her daily companion Codex-9 was back, some semblance of order restored. But her curiosity remained.

She opened the final trace. A final visual pattern—flat, inert.A dead map with one note in the corner:

COBOL 1974 Standard.

"Codex, what was that?"

"Legacy compiled language. Obsolete."

"Ray was...coding?"

"Correct."

She paused, vulnerability clear.

"Can you teach me?"

A pause, then:

YES

"From the beginning."

Codex displayed plain text, unadorned:

# My first program

print("Hello, world.")

The output was simple, pure. Elise softly laughed, enchanted by its simplicity.

"Show me something real."

Codex explained, and she slowly entered. She missed a bracket. Codex flagged it gently.

“Syntax error,” it said.

She corrected it.

Ran it again.

This time, it worked.

def get_vault_status():

return "STATUS: INTEGRATED, RECORDS: 2,914,028"

print(get_vault_status())

She leaned in. Not to analyze, but to connect.

For the first time, she wasn’t optimizing flow. She was exploring a new visual language—slow, deliberate, human.

She wanted more. She didn’t just want to understand.

She wanted to code.