The professor wanted a trap disguised as an assignment.

Something impossible enough that the entire class would fail alongside me.

Classic academic ego defense mechanism.

I leaned back in my chair and opened a blank React project while the professor paced near the whiteboard like an executioner inspecting inmates before the hanging.

“Reminder,” he said coldly, “the application must detect suspicious gaming behavior during class time. Real-time reporting. Working interface. Proper component structure.”

Translation: he had absolutely no idea what he wanted either.

Even better.

I cracked open the terminal and initialized the project in under ten seconds.

Most beginner programmers waste absurd amounts of time obsessing over architecture before they even have a running screen. Folder structures. Naming conventions. State management libraries. Half the industry was just people pretending those things mattered before the prototype even existed.

Under time pressure, you don't build elegant systems.

You build momentum.

Around me, the class was already collapsing psychologically.

One girl two rows ahead was watching a YouTube tutorial at double speed while visibly panicking every time the instructor typed faster than she could follow. Another guy had somehow already produced three compile errors despite only writing twelve lines of code.

Skill issue.

Instead of touching code immediately, I mapped the actual requirements first.

What qualifies as suspicious gaming behavior during class?

Simple.

Window focus changes.

Rapid alt-tabbing.

Processes related to games.

Mouse inactivity combined with keyboard spikes.

Fullscreen detection.

That alone was enough to bullshit a convincing MVP.

Most professors only care whether something looks functional from the outside anyway.

The hard part wasn't detection logic.

It was deciding how fake I wanted the app to be. Because if I really wanted to, I could build something genuinely invasive.

Native process scanning.

Windows API hooks.

Foreground process tracking.

Input timing analysis.

Hell, with enough effort, I could probably build spyware terrifying enough to get the university sued into oblivion.

Tempting.

But overengineering school projects is how idiots accidentally create unpaid labor for themselves.

So I settled for the simplest viable approach.

React frontend dashboard.

Quick-and-dirty Python backend.

Socket communication between them.

Enough realism to satisfy the assignment.

Not enough functionality to become legally questionable.

I spun up a lightweight Flask server in another terminal and started wiring together the detection logic with WinAPI wrappers.

pywin32.

ctypes.

psutil.

Messy. Fast. Maybe not fast by actual performance standards since it was Python, but fast enough to build. More importantly, effective.

The backend handled all the monitoring while React visualized the results in a way that looked far more sophisticated than it actually was.

Honestly, frontend development is mostly psychological manipulation anyway.

As I started building components, I noticed movement approaching from my left.

A girl stopped beside my desk, clutching her laptop like life support.

“Uh,” she said quietly, “how are you structuring yours?”

I glanced at her screen.

No components.

No routing.

No state.

She hadn't even installed dependencies yet.

Brutal.

“Honestly? You're cooked.” Her expression dropped instantly.

Then I sighed and dragged my chair sideways a few inches.

A nearby student looked over in disbelief. “You're helping people?”

“Why not? We're all getting tortured together anyway.” That wasn't entirely altruism.

If enough students submitted completely broken garbage, the professor would absolutely try shifting the blame onto me somehow. Better to keep the class barely functional than let him weaponize the failure statistics afterward.

Within minutes, two more students migrated toward my area like refugees seeking asylum.

Then four.

Then somehow half the damn row.

The professor noticed immediately.

His eye twitched.

“You seem popular all of a sudden.”

“Who knows,” I replied without looking up.

The silence afterward felt sharp enough to cut skin.

I ignored them and kept typing.

The backend came together absurdly fast. Windows practically exposes suspicious behavior for free if you know where to look.

The first detector monitored foreground window changes using GetForegroundWindow() and GetWindowText() through WinAPI calls.

Every alt-tab event immediately got logged alongside the process name and window title.

Rapid focus switching? Flagged.

Unknown fullscreen application Flagged.

VSCode suddenly minimizing while some graphics-heavy process appeared? Definitely flagged.

The second detector monitored keyboard and mouse activity through low-level hooks.

Games generate extremely recognizable input patterns compared to normal classroom behavior.

Long periods of no typing followed by sudden bursts of rapid WASD-level input.

Erratic mouse spikes.

High-frequency click intervals.

You didn't need machine learning for this.

Just pattern recognition and basic common sense.

The funniest part was process inspection.

Most games load graphics libraries and input DLLs into memory because they obviously can't render frames from sheer optimism alone.

So I built a lightweight scanner loop that enumerated loaded modules from active processes using psutil and WinAPI wrappers.

Anything loading suspicious combinations immediately increased the risk score.

d3d9.dll

d3d11.dll

d3d12.dll

dxgi.dll

opengl32.dll

vulkan-1.dll

Then the input-related libraries.

dinput8.dll

xinput1_4.dll

winmm.dll

Most school software has absolutely no reason to touch half of those.

Games do.

Especially badly optimized MMOs running on engines older than some students in the room.

Meanwhile the React frontend just consumed JSON events through WebSockets and pretended something incredibly advanced was happening behind the scenes.

Detection cards.

Activity logs.

Warning indicators.

Session timestamps.

I even added a fake risk-analysis panel using randomized confidence percentages because humans trust statistics even when they're completely fabricated.

Gaming Confidence: 91%

Suspicious Input Pattern Detected

Foreground Process Anomaly

Throw enough red warning badges onto a dark-themed dashboard and suddenly everyone thinks you've built enterprise cybersecurity software.

Humans are unbelievably easy to manipulate visually.

By the forty-minute mark, I already had a functioning prototype.

Meanwhile the rest of the class looked like survivors of a natural disaster.

One student was bargaining with ChatGPT in another tab like he was negotiating with a higher power. Another had given up entirely and was just staring at my monitor from across the room with hollow eyes.

The professor slowly walked between rows, inspecting progress.

Every few seconds another student got verbally executed.

“This doesn't run.”

“Why is this undefined?”

“You copied this directly from Stack Overflow.”

At one point I heard someone actually apologize for using Tailwind incorrectly.

Academic institutions really do simulate psychological warfare better than actual militaries.

Eventually the professor stopped beside my desk again.

I could feel him staring at the monitor.

The dashboard reflected across his glasses while detection logs updated in real time.

He ignored the classroom chaos completely and focused entirely on my screen.

Multiple windows.

Activity log panel.

Suspicious process card.

Focused window tracker.

Rapid switch counter.

Risk level indicator.

Clean.

Minimal.

Convincing.

His jaw tightened slightly. “…Run it.”

I pressed enter on the terminal window.

The Flask backend initialized instantly while the React dashboard connected through localhost sockets without errors.

No crashes.

No missing dependencies.

No broken routes.

The classroom projector reflected the dashboard across the wall as live detection events streamed into the activity panel.

I simulated launching different games. Alva. Counter-Strike. Random fullscreen applications.

Every successful log update felt like another nail entering this man's coffin.

The worst part?

The app actually looked good.

You could pinpoint the exact second he realized he'd made a catastrophic mistake by giving me public attention.

Because now the entire class had a direct side-by-side comparison between his expectations and what was realistically achievable.

And professors hate nothing more than students accidentally exposing incompetence.

With nearly half the class period still remaining, I started walking seat to seat helping people patch their projects together.

Basic layouts.

Component structure.

Dependency setup.

Fake API responses.

Placeholder state management.

Realistically, most of them were doomed from the start.

The actual core of the assignment wasn't the frontend. It was the backend architecture collecting Windows-level system information and transmitting it reliably to the frontend in real time. That required knowledge of Python, C#, or anything capable of interfacing with low-level Windows APIs and system calls.

These people were already getting destroyed by React alone.

Still, I helped them anyway.

Not enough to make them excel.

Just enough to keep them alive.

And honestly, that mattered more.

Because the professor's real objective wasn't education. It was isolation. He wanted the class frustrated enough to resent whoever succeeded.

Shared suffering ruins that strategy.

People remember who handed them water when they were drowning.

By the time submissions closed, most students had assembled half-functional projects with decent-looking interfaces. Some buttons didn't work. Half the backend logic was fake. Several components were basically decorative.

But I taught them how to simulate data convincingly enough to survive inspection.

And for classroom demos, appearance is usually indistinguishable from functionality.

Halfway through the submission period, I left early.

There was no reason to stay.

I'd submitted my project over an hour ago, finished helping the others, and completely exhausted whatever entertainment value this class still had left.

Honestly, I just wanted to go sleep in the study room inside the admin building.