DEV Community: Sprime

I reverse-engineered manhwa power systems into a real habit RPG — the game design archaeology of SYD

Sprime — Fri, 06 Mar 2026 19:08:47 +0000

There's a panel in I Am a Sorcerer King where the MC's Luck stat hits 1000 through accumulated effort. He becomes a god.

I started wondering: what if luck isn't abstract? What if it has components you can actually build?

Looks it up. It does.

Preparedness — skill, hard work, readiness
Active pursuit — putting yourself where opportunity finds you
Intuition — pattern recognition from experience
Resilience — converting bad luck into good

Things you can track. Things you can level up. Like stats.

So I built SYD — a self-improvement RPG that runs in the browser. Then I spent a long time asking: what makes effort feel real and weighty in games, and how do I reverse-engineer that into real-world mechanics?

This is what I found.

The game design archaeology

1. Shadow of Mordor's Nemesis System → The Behavioral Trace

In Shadow of Mordor, enemies remember your failures. They adapt to your specific weaknesses and grow stronger from them.

SYD has a rolling 30-day Behavioral Trace — a black box log of what you do and what you consistently ignore. World Bosses that map to neglected stats grow stronger from that stagnation. Your to-do list becomes a living narrative with consequences.

// Each day logs: { date, completed: [{stat, xp}], loggedIn: true }
// Entries older than 30 days pruned on read
// The trace feeds the AI processor context on every call
function loadTrace() {
    const raw = localStorage.getItem(TRACE_KEY);
    const trace = raw ? JSON.parse(raw) : [];
    const cutoff = new Date();
    cutoff.setDate(cutoff.getDate() - 30);
    return trace.filter(e => new Date(e.date) >= cutoff);
}

2. Zelda's Ability Gating → The Power Play

In Zelda, you find the hookshot specifically to pull off a boss's armour. The right tool for the right lock.

SYD's AI processor identifies your highest momentum stat and frames it as the key to a World Boss's defence. If you've been grinding Intelligence hardest and a Strength boss appears, the system finds where your sharpest weapon still applies. Growth feels powerful — you're rewarded for depth.

3. Skyrim's Radiant AI → The Efficiency Bridge

Bethesda's Radiant system generates tasks based on where you are in the world. SYD generates them based on where you are in your habits.

If you've been avoiding a stat, the AI finds a way to layer it onto something you already do. Listen to an Intelligence brief during a Strength run. Stack a Charisma directive onto a routine you keep. Activation energy drops. Growth feels easy.

4. Pokémon Type-Matching → Stat-Weighted Boss Damage

Type matters. Targeting matters.

World Bosses have a primaryStat and linkedStats (AI-generated on boss creation). The damage model:

// Three-tier stat-weighted damage
const primaryMatch = b.stat === stat;
const linkedMatch  = Array.isArray(b.linkedStats) && b.linkedStats.includes(stat);
const multiplier   = primaryMatch ? 1.0 : linkedMatch ? 0.6 : 0.1;
const dmg          = Math.max(1, Math.round(baseXP * multiplier));

Incursions (AI-generated missions) follow the same logic but hit harder on match: 1.5× / 0.9× / 0.15×.

You can beat a boss with unfocused effort. It just takes much longer. The cost of untargeted work is visible.

5. Dead Space's Diegetic UI → The Base Map

Dead Space put health and ammo on Isaac's suit — information inside the world, not overlaid on it.

SYD's map is a 3×3 facility grid you navigate as an operator. Your avatar moves between nodes with a CSS transition and a dot trail. You don't click tabs — you move through a space. The terminal becomes a place.

// Avatar moves between facility tile centres
// Three dots drawn at 25%, 50%, 75% along the path, then fade
function drawDotTrail(viewport, from, to) {
    [0.25, 0.5, 0.75].forEach((t, i) => {
        const dot = document.createElement('span');
        dot.className = 'map-trail-dot';
        dot.style.left = (from.x + (to.x - from.x) * t) + 'px';
        dot.style.top  = (from.y + (to.y - from.y) * t) + 'px';
        viewport.appendChild(dot);
        setTimeout(() => dot.classList.add('map-trail-dot--visible'), i * 40);
        setTimeout(() => { dot.classList.remove('map-trail-dot--visible'); setTimeout(() => dot.remove(), 400); }, 800);
    });
}

The philosophy

The thread through all of it: the system should be a tactical advisor, not a boss.

Most productivity tools tell you what to do. SYD watches what you've actually done and scouts the path of least resistance. Smart over hard. Always.

The stack

Vanilla JS + HTML + CSS
Firebase Firestore (cloud save, opt-in)
Web Audio API (four-layer ambient system)
Service Worker (offline + PWA)
No framework. No bundler. No dependencies.

Deliberately minimal. Needs to run on low-end devices and slow networks.

Live terminal

syd-protocol.github.io/terminal

Open source under AGPL-3.0. Contributions welcome — especially around game design, performance, and quest content.

Go awaken an operator.

Build log: Making product onboarding actually engaging (codename: Path)

Sprime — Sat, 14 Feb 2026 15:50:03 +0000

Three experiences, one pattern:

1. Path of Exile - Complex game, overwhelming onboarding despite extensive wikis

2. Delta Force - Coming from COD's DMZ (tutorials everywhere) to this (figure it out yourself)

3. Aden - Got invited to contribute to their AI agent platform (github.com/adenhq/hive). Message said: "Star, Fork, Watch the repo, create issues, submit PRs. Join Discord for questions."

Good docs. Still had to piece together my own path through Discord → GitHub → issues → PRs → contribution patterns.

My background:

Researched learning extensively
Built my own learning framework
Tried building 2 learning startups
Managed open-source maintainer communities

Even with that, I found these onboarding processes challenging.

The moment it clicked:

Found a YouTube tutorial on Path of Exile (https://youtu.be/ZWLpP-Z6sCM?si=0L3KN0ntxYUqmdOq) that simplified it so well, I was eager to try the game again.

Realisation: Good learning doesn't just inform. It makes you want to engage.

The pattern:

Bad onboarding experiences + learning research background + startup attempts + proof that good learning works = something worth building.

What I'm building:

An AI agent (codename: Path, from Path of Exile - fit well looking backwards) that:

Listens to knowledge sources (GitHub, Discord, Twitter, YouTube, wikis)
Processes through AI
Generates structured learning content that drives engagement
Delivers where people are (Discord bots, Telegram, learning hubs)

Architecture:

Knowledge Sources → Adapters → AI Processing → Formatters → Distribution

Layer 1 - The Ear:

Adapters for each source (GitHub, Twitter, etc.)
Converters that standardise the data
Philosophy: Keep only what helps create engaging learning content

Layer 2 - The Brain:

AI processing (Gemini free tier initially)
Extract learning-relevant info
Remove jargon, add context
Structure for engagement, not just information

Layer 3 - The Voice:

Formatters for each channel
Discord bots, Telegram messages, learning hub content
Optimised for how people actually learn

MVP scope:

# Input: GitHub webhooks only
# Processing: Gemini 1.5 Flash (free tier)
# Output: Discord bot only
# Stack: Python, Flask, discord.py, Supabase

# All free tier
# All documented

Why I'm building this publicly:

Looking for work. My career is product management + community management + product engineering + learning research. Varied companies, varied contexts.

Hard to explain on a CV. Easier to build something: "Here's the code. Here's what I made. Here's how I think."

Contributing:

Not recruiting, but if you want to build your portfolio publicly too, you can contribute.

I have a registered company (Nigeria), so it's verifiable work experience.

If it makes money eventually, everyone shares revenue. But the goal is portfolios and getting hired.

What I'm documenting:

Setup and architecture decisions
Code walkthroughs
Weekly progress
Problems I hit
What's working, what isn't

Just building and sharing the process.

Current status:

Setting up repo structure
Writing contributing docs
Building first GitHub webhook listener
Basic Gemini integration

Complete MVP (GitHub → AI → Discord)
Expand sources (Twitter, YouTube, Slack)
Expand channels (Telegram, learning hubs)

Links:

GitHub: [will update when ready]

Discord: [will update when ready]

If you've worked on similar problems or have thoughts on learning systems, would be interested to hear.