DEV Community: SemTiOne

Position Evaluator — A Chess Diagnostic for Your Daily Decisions

SemTiOne — Mon, 13 Jul 2026 01:44:28 +0000

This is a submission for Weekend Challenge: Passion Edition

What I Built

I've been obsessed with chess for years, and I kept noticing that a handful of chess concepts describe everyday life decisions better than any generic advice ever could. "Zugzwang": being forced to move when every option makes things worse. "Fork": one situation threatening two things you care about at once. "Zwischenzug": sneaking in a small unrelated move before dealing with the real problem.

So I built Position Evaluator, a daily diagnostic log that takes a short description of a decision or situation you're facing, and classifies it into one of seven formal chess concepts using Gemini, such as Zugzwang, Fork, Prophylaxis, Gambit, Zwischenzug, Overextension, or Tempo Loss. You get a classification, a confidence level, and a short clinical explanation of why. Then, over time, a dashboard shows which "condition" you land in most often.

It's a structured classification system with a strict decision order. The interface leans into the bit too, it's styled like a hospital lab-requisition form crossed with a chess scoresheet, complete with a stamped classification badge, a case-file number, and a "clear all records" control for starting a fresh log.

Demo

Code

SemTiOne / position-evaluator

Position Evaluator

Daily diagnostic log that classifies your personal decisions into formal chess concepts (Zugzwang, Fork, Zwischenzug, Prophylaxis, Gambit, Overextension, Tempo Loss) using Gemini structured output. Built for the DEV Weekend Challenge: Passion Edition.

Setup

python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate
pip install -r requirements.txt

cp .env.example .env
# edit .env: add your GEMINI_API_KEY and MySQL credentials

mysql -u root -p < schema.sql

python app.py
# open http://127.0.0.1:5000

Running tests

# fast, no API calls, safe to run anytime — this is what CI runs on every push
pytest tests/ -k "not eval_set"

# slower, calls the real Gemini API, costs quota — run after editing the
# system prompt in gemini_client.py to check for prompt drift
pytest tests/ -k "eval_set"

.github/workflows/test.yml runs the deterministic tests on every push/PR to main. The Gemini eval-set tests are deliberately excluded from CI. They call…

View on GitHub

How I Built It

Stack: Python (Flask), MySQL, Gemini API (gemini-3.1-flash-lite) via the google-genai SDK, vanilla JS/CSS frontend.

Seven overlapping chess concepts can describe the same situation in slightly different ways ("procrastinating on a task to watch anime" could plausibly read as either Zwischenzug or Tempo Loss). I solved this by giving Gemini an explicit decision order in the system prompt; check for Fork first, then Zugzwang, then Prophylaxis, and so on down to Tempo Loss as the default; rather than asking it to "pick whichever fits best" from a flat list. That single change made classifications far more consistent across similar inputs.

The other detail I'm most proud of is that the Pydantic schema for Gemini's structured output declares reasoning before classification. Since Gemini's controlled JSON generation fills fields in the order they're declared, this forces the model to articulate its reasoning before it's allowed to commit to a label.

I also intentionally didn't build a numeric confidence score. LLMs aren't well-calibrated at self-reporting a percentage like "87% confident," so instead of a falsely precise number, the model picks a categorical low / medium / high bucket based on whether the situation contains an explicit signal for its chosen category, or is more of an inference.

That same principle got tested again late in the build, when I wanted a chess-engine-style evaluation score next to each badge for extra flavor, something like FORK [-2.5]. The tempting shortcut was to just ask Gemini to invent that number too. I didn't, for the same reason as above, it would've quietly reintroduced the exact false precision I'd deliberately avoided with the confidence bucket. Instead, the score is computed deterministically in plain code, from a fixed lookup table keyed on the classification and confidence Gemini already returned.

Everything else, like the entry log, the duplicate-submit handling (same-day identical entries return the existing diagnosis instead of creating a new row), and the distribution dashboard, is built around one goal: making the "diagnostic report" feel real.

Prize Categories

Submitting for Best Use of Google AI. The entire product only works because of Gemini's structured output support (response_schema bound to a Pydantic model).

StandupBot

SemTiOne — Sat, 11 Jul 2026 12:23:10 +0000

A CLI tool that reads your recent git commits and generates a standup update — Yesterday / Today / Blockers, ready to paste into Slack, Jira, or wherever your team posts standups.

standup

That's the command. It reads commits from the last 24 hours (configurable), classifies them, and generates the summary.

Two backends, both free

Provider	Cost	Where it runs
Ollama	Free	100% local
Groq	Free tier	Cloud

No subscription. Run it with Ollama and nothing leaves your machine.

If you use Groq, commit messages get scanned and redacted before they're sent — private IPs, internal hostnames, GitHub tokens, AWS keys, Slack tokens, API keys, credentialed URIs.

Caching + rate limiting

Cache key is a hash of your actual commit hashes. If nothing changed since your last standup, it serves the cached result instead of calling the LLM again. There's also a cooldown + daily cap so a script or a bad habit can't burn through a free tier's quota.

Output formats

standup --template slack
standup --template jira
standup --raw
standup --copy

Five built-in templates, or define your own with a fixed set of variables ({yesterday}, {today}, {blockers}, {repos}, etc.), no arbitrary format-string injection.

Quality scoring

Every generated standup gets scored 0-100. Set a minimum score and it retries with refined guidance up to twice before returning what it has.

Install

pip install -e .
standup --setup
standup

For Ollama:

ollama pull llama3

Contributing

MIT-licensed. A few scoped "good first issue" tasks are open if you want to look at the codebase without needing full context first.

Repo: github.com/SemTiOne/standup-bot

Heatmap Bot v1.2.0 - Automating Ko-fi Payments with Webhooks

SemTiOne — Fri, 20 Mar 2026 03:02:32 +0000

Quick update on Heatmap Bot - just shipped v1.2.0.

The main change: automated Ko-fi activation

Previously the payment flow was painful:

Customer pays on Ko-fi
I get an email notification
I manually run /grant in Discord
Customer waits

Now:

Customer pays on Ko-fi, includes their Discord Server ID in message
Ko-fi webhook fires
Bot parses the Server ID from the message
Paid tier activates instantly

The activation code system handles edge cases where they forget their Server ID.

Other changes

/announce command — lets me broadcast updates to subscribed servers
Feedback reference IDs (#A3F92B1C) for support tracking
Brute force protection on /activate — max 5 attempts/hour
HMAC verification on Ko-fi webhooks

Full bot: https://ko-fi.com/semtione

Invite Link: https://discord.com/oauth2/authorize?client_id=1482225606761386085&permissions=2147601408&integration_type=0&scope=bot+applications.commands

How I Added Paid Tiers to My Discord Bot Without Stripe or Any Payment API

SemTiOne — Tue, 17 Mar 2026 07:46:18 +0000

Most tutorials for monetizing a Discord bot assume you'll integrate Stripe or LemonSqueezy directly into the bot.

I went a different route, manual grants via Ko-fi. Here's why and how.

The problem with payment APIs in bots

For a new bot with low volume, integrating a full payment API means:

Webhook endpoints to maintain
Subscription management logic
Refund handling
Failed payment handling

That's a lot of complexity for a bot that might have 10 paying customers at launch.

The Ko-fi manual grant approach

Instead, I set up Ko-fi as the payment page and handle grants manually:

Customer buys on Ko-fi
I get a notification
I run /grant guild_id:123456 days:30 in my admin server
Bot updates the database and unlocks paid features

python@app_commands.command(name="grant")
async def grant_paid(self, interaction, guild_id: str, days: int = 30):
    if not await is_bot_owner(interaction):
        return
    expires_at = int(time.time()) + (days * 86400)
    await upsert_subscription(self.db, guild_id=guild_id,
                               tier="paid", expires_at=expires_at)

When to upgrade to automated payments

Once you hit ~20-30 paying customers, the manual process gets tedious. That's when it makes sense to add Ko-fi webhooks (requires Ko-fi Gold) or switch to Stripe.

For now, manual is fine, and it means I talk to every single customer personally.

The result

Clean, simple, zero ongoing maintenance cost. Works well for early stage.

Invite Link: https://discord.com/oauth2/authorize?client_id=1482225606761386085&permissions=2147601472&integration_type=0&scope=bot+applications.commands

Full bot: https://ko-fi.com/semtione

How I Built a Discord Activity Heatmap Bot with Python and discord.py

SemTiOne — Tue, 17 Mar 2026 07:40:35 +0000

I've been running a Discord server for a while and always wondered: "when is my community actually online?"

Discord doesn't show you this. You can see who's online right now, but there's no way to see patterns over time, no weekly view, no hourly breakdown, nothing.

So I built Heatmap Bot.

What it does

Heatmap Bot tracks your server's activity and turns it into a heatmap, a 7×24 grid showing activity by day and hour for the past week. It also supports:

Daily bar chart view
Monthly trend chart
Channel breakdown
Member leaderboard
Week-over-week comparison
Weekly auto-reports
Peak activity alerts
CSV data export

Tech stack

Python 3.13 with discord.py 2.x
SQLite with aiosqlite for async DB access
matplotlib + numpy for heatmap rendering
aiohttp for the webhook server
Railway for hosting
Ko-fi for payments (manual grant flow)

The interesting part, rendering heatmaps

The heatmap is a 7×24 numpy array. Each cell is the count of events at that day/hour combination, converted from UTC to the server's local timezone.

pythondef aggregate_to_heatmap_grid(events, timezone, days):
    grid = np.zeros((7, 24), dtype=float)
    tz = pytz.timezone(timezone)
    for event in events:
        ts = event.get("timestamp", 0)
        dt = datetime.fromtimestamp(ts, tz=tz)
        grid[dt.weekday()][dt.hour] += 1
    return grid

The rendering uses matplotlib with a custom blurple→pink gradient to match Discord's aesthetic.

The hard part - Railway + Discord rate limits

The trickiest issue was Discord's Cloudflare rate limiting. Too many reconnects from the same IP gets you a 1015 error, temporarily banned. The fix was switching Railway regions to get a new IP.

If you're deploying a Discord bot, make sure your restart policy doesn't cause rapid reconnect loops.

Free vs paid tier

Free: 7 days history, messages only, watermark
Paid ($4.99/month): 90 days, all event types, no watermark, leaderboard, CSV export

Try it

Add Heatmap Bot to your server: https://discord.com/oauth2/authorize?client_id=1482225606761386085&permissions=2147601472&integration_type=0&scope=bot+applications.commands

Ko-fi: https://ko-fi.com/semtione

Happy to answer questions about the implementation in the comments!

StandupBot – Generate daily standups from git history using Ollama or Groq

SemTiOne — Thu, 12 Mar 2026 08:11:32 +0000

Tired of trying to remember what you did yesterday for standup?

I built StandupBot, a CLI tool that reads your git history and generates a clean standup summary using a local or free cloud LLM. No paid APIs required.

Features

Private with Ollama (runs locally)
Free cloud option via Groq
One command: standup
Copy to clipboard: standup --copy
Health check: standup doctor

Quick Start

Install Ollama from https://ollama.com, then:

ollama pull llama3
pip install -e .
standup --setup
standup

Example Output

**Yesterday:** Fixed authentication bug and refactored token validation.
**Today:** Working on the new /users endpoint.
**Blockers:** None

🔗 https://github.com/SemTiOne/standup-bot

Feedback welcome!