The Grey Crawler's corpse was still on his floor. It smelled like wet copper and ozone — a chemical sharpness that clung to the back of his throat. Zhang Wei stepped over it to reach the kitchenette, filled a glass of tap water, and drank. The water tasted normal. The apocalypse hadn't gotten to the plumbing yet.

He sat at his desk, pushed the extinguisher aside, and cleared a space between the scattered filing cabinet drawers. The dead monitor lay face-down on the carpet. One screen left. His behavior tree editor, still running, the Lich King's wireframe hand still clipping through the dungeon floor.

He closed it. Minimized fifteen years of professional work and opened a blank text document instead. Then he stopped. The text file was a software record. Editable. Deletable. System-interfaced.

He reached into the filing cabinet and pulled out a legal pad and a pen. Real ink on paper. No System overlay, no digital dependency. He clicked the pen and wrote at the top of the first page:

SYSTEM OBSERVATION LOG — DAY 1

Then he set the pen down and opened his character sheet.

He had seen it once before — the initial stat screen at Level 1, before the patch notes consumed his attention. But now, with the Grey Crawler's death fresh in memory and twenty-five experience points spent, he wanted the full readout.

The mental command came as naturally as blinking. The sheet materialized in his vision:

CHARACTER SHEET

Name: Zhang Wei Level: 2 (XP: 25 / 100) Class: Unlocked at Level 10 Title: None

STATS STR: 8 | DEX: 11 | CON: 10 | INT: 16 | WIS: 14 | CHA: 11 HP: 100/100 | MP: 0/0 | SP: 0

Passive Abilities: Code Sight Lv.1 — Cannot deactivate. Grants enhanced perception of System entities and data structures. Mana cost: None. Cooldown: None.

Active Abilities: None (Class required)

Status Effects: None

He studied each number. Six primary stats, distributed identically to a D&D character sheet except for the absence of class bonuses. No class meant no passive stat multipliers, no skill tree, no specialization. He was vanilla — a blank template running on base values alone.

INT 16. The only stat that mattered to him right now. In game design, INT determined information processing speed and anomaly detection range. Code Sight had already demonstrated that it responded to his INT stat — the data sharpened and expanded when he focused. At Level 16, he could read basic entity data at close range. What would INT 20 look like? INT 30?

He wrote on the legal pad:

Level 2 — base stats confirmed. Class locked until 10. No active abilities. Code Sight Lv.1 (passive, always-on). MP shows 0/0 — no mana pool without class. This limits Code Sight to passive scanning only. Can't force deeper reads yet.

He paused. Code Sight was active right now, as it always was. It had been feeding him data since the System activated — HP bars, damage ranges, entity classifications. But in the fight with the Grey Crawler, something else had appeared. Something he hadn't processed in the adrenaline.

He focused on the corpse.

Code Sight pulsed. The data came automatically, no effort required:

ENTITY: Grey Crawler (Deceased) HP: 0/0 Level: 2 STR: 12 | DEX: 14 | CON: 10 TYPE: Hostile — Vermin Class DAMAGE RANGE: 8-14 per strike Resistance: Physical (Blunt) — 15%

Below the stat block, faint red text he had not seen during the fight. It flickered at the edge of his perception, as if the System had written it in a smaller font:

[DEV_ANNO] Alpha Build — Test Subject #4721 [SPAWN_TABLE] Urban_Density_Tier3 — Residential_Highrise [AI_TEMPLATE] Vermin_Patrol_v0.3 — Aggressive_Proximity

He stared at it.

In fifteen years of game development, he knew exactly what that text was. Internal annotations. Developer notes embedded in entity data for QA purposes — the kind of tags that testers used to track which build a creature belonged to, which spawn table generated it, which AI behavior tree drove its decisions. Every game had them. Players never saw them. They existed in the source code, visible only to the development team.

But he was not a developer of this system. He was a player. A test subject, according to the annotation itself. Test Subject number forty-seven twenty-one.

And yet he could see it.

He wrote quickly:

Code Sight — ANOMALY. Shows developer annotations not visible in standard entity data. Tags include: build version, spawn table ID, AI template version. This is source-code-level metadata. Standard player UI does NOT show this. Code Sight is not a standard ability.

He underlined "not a standard ability" twice.

The implications sat in his chest like a cold weight. Code Sight had been granted to him — but either the System didn't know what it had given him, or it had given him this deliberately. Both options were troubling. If the System didn't know, then Code Sight was a bug. If it did know, then Zhang Wei was being tested differently than everyone else.

His phone buzzed. The 5B number.

I hear something in the hallway. Scratching. Is it near you?

He typed back: It was. I killed one. The thing is dead now. Stay in the bathroom. Lock the door from the inside.

A pause. Then:

You KILLED it? How?

Dumbbell and a fire extinguisher. It was Level 2. Not hard if you can see its stats.

See its stats? What do you mean?

The System stat screen. The floating text. It shows you their HP, strength, damage.

A long pause. Fourteen minutes, according to his phone clock. Then:

I don't have floating text. I see a blue screen with MY stats. But nothing on them. Nothing on the monsters. What am I missing?

Zhang Wei set the phone down. Stared at it.

Everyone had the System. Everyone received stat screens, patch notes, the base interface. But Code Sight — the ability to see entity data, damage ranges, resistances — that was his. His alone.

He typed: It might be a class ability. Or a passive. Did you get any abilities when the System activated?

No. Just the stat screen and a message saying Class unlocked at 10.

He had expected that. Everyone got the same base package. Code Sight was the variable. His variable.

He typed: Stay where you are. I am documenting everything I can see. When it is safer, we should talk. What is your name?

Li Hua. I was a graduate student. Biomechanical engineering.

Zhang Wei. Game developer.

Another pause.

You design video games. And you can see monster stats.

Yes.

That is either very useful or very insane right now.

He almost smiled. Almost.

Both, probably. Hang tight, Li Hua.

He put the phone on the desk and returned to the legal pad. The annotations he had seen — Alpha Build, Test Subject number, Spawn Table, AI Template — followed a naming convention he recognized from work. Underscores between words. Version numbers. Tier classifications. This was not alien language. This was software engineering written by someone who thought like a software engineer.

He flipped to a new page and began writing:

PATTERN ANALYSIS — Patch Notes Structure

1. Format: Standard release documentation. Headers, bullet points, known issues section. This mirrors internal documentation used by studios before public-facing patches. The "Known Issues: None" footer is dead giveaway — only internal documents use that format. Public-facing releases always say "Known Issues: See FAQ" or similar.

2. Author: "Automated — Test Framework v1.0." No human author. No entity name. The System generates its own patch notes based on test performance data. In software terms, this is continuous integration — the system monitors, evaluates, and writes its own updates.

3. Cadence: 30-day deployment cycle. Matches live-service game cadence exactly. Monthly patches with 72-hour advance notice. This is a controlled rollout, not a chaotic event.

4. Developer Annotations on entities: Alpha Build labels, spawn table references, AI template versions. These are QA tags. They exist so developers can track which version of content is deployed. The presence of version numbers (v0.3 for AI templates) means these are being iterated. Updated. Improved.

Hypothesis: The System is running a beta test. Humanity is the test group. Patch notes are progress reports. Developer annotations are QA tracking. Monthly patches are iterative improvements based on performance data. We are not players in a game. We are subjects in a controlled experiment.

He set the pen down. His handwriting had gotten tighter as he wrote, the letters pressing harder into the paper. His hand was steady. His pulse was not.

This was the kind of hypothesis he would have written as a bug report at work. Clinical. Evidence-based. The kind of report that got taken seriously because it didn't editorialize — it just presented observations and let the reader draw conclusions.

Except the bug was reality. And the fix was whatever the System decided to deploy next.

He tore the page from the pad and folded it, then tucked it under the legal pad's cardboard backing. If the System monitored digital records, paper was safe. If it monitored physical records too, well — a folded page under cardboard wasn't exactly covert, but it was the best he could do at Level 2 with no class and no skills.

He picked up the pen again and listed what he needed:

Priority objectives:

• Reach Level 10. Choose a class. Every level without a class is a wasted power budget.
• Test Code Sight limits. Range, depth, conditions that affect clarity.
• Map the building. Survivors, monsters, resources. Build an intelligence picture.
• Monitor for changes. If this is a beta test, the system will adapt. Need to detect adaptations before they deploy.

He underlined the last item and added a note: Code Sight showed entity data others can't see. Annotations suggest the data has layers — surface stats for everyone, source-code data for him. If the System adapts, the annotations will change first. He needs to watch the annotations.

Outside, something howled. Not a Grey Crawler — deeper, resonant, vibrating through the concrete walls. A different creature. The howl rose, held, then dropped into a clicking series of pulses that sounded almost like communication.

Zhang Wei looked toward the window. Through the gap in his blinds, the street below flickered with blue light — the same System-blue that had replaced every screen in the building. The blue light pulsed in a rhythm he hadn't noticed before. Not random. Structured.

Code Sight activated automatically, and for the first time since killing the Grey Crawler, the data that flooded in was not about an entity.

It was about the environment itself.

Faint text materialized at the edge of his vision, overlaying the street, the building across the road, the sky. Unlike the clean entity data he had read before, this was fragmented — half the characters scrambled, the other half sharp:

[ENV_SCAN] Urban Zone 7-Alpha Spawn density: 3.2 entities/block — ABOVE PROJECTION Player survival rate: 61% — WITHIN PARAMETERS Difficulty scaling: ADJUSTING

The text flickered. The last line scrambled, unscrambled, then solidified:

[DEV_ANNO] System_Watchdog flag raised — anomalous perception detected in Sector 7-Alpha. Monitoring escalated. Review queued.

His blood went cold.

It had detected him. Not his combat, not his location — his perception. Code Sight had seen something the System didn't want seen, and now the System was watching.

The blue light in the street pulsed once more, then faded. The howl outside went silent. Everything went silent, as if the city itself had taken a breath and held it.

Zhang Wei sat very still. The pen trembled in his fingers. He set it down carefully, picked up the legal pad, and wrote one final line:

It knows I can see it.

Then he sat in the dark of his apartment, one monitor dead, one monitor glowing, a Grey Crawler's corpse cooling on the floor six feet away, and waited for whatever came next.