🧟 나는 내 Task Manager를 Zombie Shooter로 바꿔서 RAM을 절약했다 (Kiro로 제작)

Source: Dev.to

It was a dark and stormy night… okay, actually it was 2 AM, my laptop fan was screaming like a banshee, and my RAM usage was sitting at a terrifying 98 %.

우리는 모두 소프트웨어 개발의 진정한 공포, Zombie Process(좀비 프로세스)를 경험했습니다—죽였다고 생각했던 고집 센 Chrome 인스턴스, Node 서버, 그리고 CPU를 잡아먹고 활동 모니터를 괴롭히는 기타 백그라운드 작업들 말이죠.

보통 이들을 처리하려면 작업 관리자를 열거나 터미널에 kill -9를 입력하는 지루한 의식을 거쳐야 합니다. Kiroween Hackathon을 위해 저는 조금 더… 프랑켄슈타인적인 방법을 시도해 보기로 했습니다.

Enter Zomb‑Kill: a Python dashboard that scans your system for idle processes and renders them as 8‑bit zombies. To free up RAM, I don’t click “End Task.” I click a shotgun. 💥

The Frankenstein Category ⚡

I entered this project into the Frankenstein category—mashing up boring system‑admin tools with arcade‑game logic. My goal was to make process management satisfyingly violent, but I only had a few hours and no time for boilerplate. I needed magic. I needed Kiro.

Vibe Coding: Summoning the Backend

If you haven’t used Kiro’s Vibe Coding feature yet, it honestly feels a bit like witchcraft.

Normally, writing a script to inspect system processes means digging through the psutil documentation, handling permission errors, and formatting dictionary outputs. I opened Kiro’s chat and simply vibed with the AI:

“I need a Python script that uses psutil to find all idle or sleeping processes. Return them as a JSON object where memory usage translates to health points and the process name is the monster_type.”

Kiro didn’t just give me a snippet; it understood the assignment and generated a class structure that treated my operating system like a dungeon crawler.

import psutil

def scan_for_monsters():
    dungeon = []
    # Scan system for processes consuming resources
    for proc in psutil.process_iter(['pid', 'name', 'memory_info']):
        try:
            # Memory usage in MB becomes Health Points
            ram_usage = proc.info['memory_info'].rss / (1024 * 1024)

            monster = {
                "id": proc.info['pid'],
                "monster_type": proc.info['name'],
                "health_points": int(ram_usage),
                "status": "ZOMBIE" if proc.status() == psutil.STATUS_ZOMBIE else "ALIVE"
            }
            dungeon.append(monster)
        except (psutil.NoSuchProcess, psutil.AccessDenied):
            pass  # Some ghosts cannot be seen

    return dungeon

The script handled exceptions for system processes (the ones you shouldn’t kill unless you want a Blue Screen of Death) automatically. I wasn’t coding; I was conducting a symphony of logic.

Giving the Monster a Brain (Steering Docs)

Now came the hard part: the graphics. I wanted to use PyGame to render the 8‑bit zombies. Most AI coding assistants hallucinate game logic, inventing methods that don’t exist and leaving you with a graveyard of syntax errors.

This is where Kiro’s Context/Steering Docs feature saved my life. I dropped the PyGame documentation into Kiro via the @docs feature and asked:

“Using the @pygame docs, create a rendering loop that takes the JSON data from our backend and spawns a sprite for every process. If I click the sprite, trigger the kill command and play a shotgun sound effect.”

Because Kiro was “holding the manual” while it coded, the output was flawless on the first try.

# Kiro generated this game loop using the PyGame docs context
running = True
while running:
    screen.fill((10, 10, 10))  # Dark mode background

    for event in pygame.event.get():
        if event.type == pygame.MOUSEBUTTONDOWN:
            # Check if we clicked (shot) a zombie
            mouse_pos = pygame.mouse.get_pos()
            for z_sprite in zombie_group:
                if z_sprite.rect.collidepoint(mouse_pos):
                    # KILL THE PROCESS
                    psutil.Process(z_sprite.pid).terminate()
                    play_shotgun_sound()
                    z_sprite.kill()  # Remove from screen

    # Update and draw the undead horde
    zombie_group.update()
    zombie_group.draw(screen)
    pygame.display.flip()

It was like stitching a new limb onto the project and watching it twitch to life immediately. “It’s alive!” I may have actually shouted at my monitor.

The Result: A Ghoulish Delight

Now, when my computer slows down, I launch Zomb‑Kill:

• Chrome Helper? A slow‑moving ghoul. BLAM.
• Frozen Python script? A fast‑moving skeleton. BLAM.

My RAM clears up, and I get a dopamine hit.

Conclusion: Coding Doesn’t Have to Be Scary 🧛

Building Zomb‑Kill proved two things:

1. Killing processes is better with sound effects.
2. Kiro changes the developer experience from “typing syntax” to “directing magic.”

The ability to use Vibe Coding to skip boring boilerplate, and Steering Docs to ensure complex libraries are implemented correctly, made this the most fun hackathon entry I’ve ever built.

If you haven’t tried Kiro yet, go grab it. It might just save your soul (or at least your memory leak).

Happy Kiroween! 🎃👻