DEV Community: sevasu

THINK ENGINE: SOLSTICE

sevasu — Sun, 21 Jun 2026 11:59:27 +0000

■ What kind of game is this?

THINK ENGINE: SOLSTICE is an interactive experience that explores the underlying shared system behind natural phenomena.

The player enters the world as an observer and explores fragments of nature—such as snowflakes, plant veins, seashell spirals, and animal patterns—that initially appear unrelated.

Through observation and progression, the game reveals that these differences are not fundamental, but rather different expressions emerging from the same underlying rule.

Ultimately, the player arrives at a simple mathematical principle behind the world: Turing patterns.

■ Relation to the theme

This work is inspired by the June Solstice (Solstice) and the ideas of Alan Turing.

The solstice represents a point of transition—the moment when daylight reaches its peak and begins to change. In this work, it is reinterpreted as a shift in perception, where the way we see the world fundamentally transforms.

Through observation and understanding, the player is led toward a perception of reality as a computable structure governed by simple rules.

■ Tribute to Alan Turing

This project is also a tribute to Alan Turing.

Its structure—from observation to understanding, and from phenomena to computation—reflects Turing’s exploration of the nature of intelligence.

By presenting natural forms not as random occurrences but as outcomes of mathematical and algorithmic processes, the work highlights how Turing’s ideas continue to resonate within the foundations of the natural world.

[Github][https://github.com/sevasu77/THINK-ENGINE-SOLSTICE]

What I Learned From DEV Challenges About Winning and Community!

sevasu — Sun, 21 Jun 2026 03:06:57 +0000

I thought DEV Challenges were about winning.

What participating in DEV Challenges taught me.

A few months ago, I joined DEV.

I didn't know many people.
I wasn't well known.
I simply wanted to become a better developer.

Like many newcomers, I believed something very simple.

"If I can win a challenge, maybe that means I'm becoming a real developer."

So I kept participating.

Sometimes I built retro games.
Sometimes I experimented with AI.
Sometimes I simply challenged myself to finish something before the deadline.

Every challenge taught me something.

Every badge made me smile.

But after several months, I realized something unexpected.

The biggest prize wasn't the badge.

I started asking myself...

What happens after the contest ends?

The badge stays on my profile.

The project goes to GitHub.

Then...

What's next?

That question stayed with me for a long time.

Then I realized something.

I had been focusing on the contest.

But the real value wasn't the contest.

It was the community.

Without DEV...

I would never have discussed ideas with developers from around the world.

I would never have received reactions from people I had admired.

I would never have met developers with completely different ways of thinking.

The challenge wasn't just building software.

The challenge was becoming part of a community.

Something I had rarely experienced before.

Most communication happens inside companies.

DEV felt different.

It gave me a place to keep showing up.

To keep learning.

To keep improving.

That matters more than I realized.

The hardest part isn't building software.

This surprised me.

As I kept building apps, I realized something.

Building an app is difficult.

But building a place where people discover that app...

is much harder.

That's when I started appreciating communities like DEV even more.

Someone had to build this place.

Someone had to create a market where beginners and experienced developers could stand on the same stage.

That's an incredible achievement.

My goal changed.

When I started...

my goal was simple.

Win a challenge.

Now...

I still want to create great projects.

I still hope to win someday.

But that's no longer my biggest goal.

Now I want to build things that continue to matter after the contest ends.

Projects.
Ideas.
Discussions.
Communities.

To anyone joining DEV for the first time:

If you're here because you want to win...

I understand.

That was me too.

But don't overlook something much bigger.

You're joining a community where people encourage each other, challenge each other, and grow together.

The badge may stay on your profile.

But the community stays with you.

I still don't know all the answers.

In fact...

I think I finally found the right question.

How can we create more places where independent developers can keep growing together?

I'd love to hear your thoughts.

Title: From Stock Market "Glitch" to Financial Education — A Cow's Journey with GitHub Copilot 🐮✨

sevasu — Wed, 03 Jun 2026 02:46:15 +0000

Introduction
This is a submission for the GitHub Finish-Up-A-Thon Challenge.

I originally built a game where a cow jumps on floating market platforms. It was tightly coupled with real-time stock data (like NVDA and ASML) via a Python backend. But while revisiting this abandoned prototype, I had a realization: Children don't care about stock ticker symbols. They care about choices, personality, and immediate impact.

With GitHub Copilot as my co-pilot, I decided to finish and pivot this project. I transformed a complex stock simulator into an intuitive financial education game where a child's "Risk Profile" alters the very physics of the game world.

[GitHub] [https://github.com/sevasu77/cow-jump-financial-literacy/tree/main]

The Evolution: Before & After

The Backstory & Pivot (The Human Intent) The original prototype was an adult-oriented "market tracker game." It required real-time API fetches, had messy if/else hardcoded logic for physics, and the text was too technical for younger minds. I wanted to turn it into a clean, arcade-like educational experience with 4 distinct asset classes:

🟦 AI Tech: High Risk / High Return (Heavy gravity, massive jump, narrow platforms)

🟩 Green Energy: Low Risk / Steady (Light gravity, low jump, extra-wide platforms)

🟨 Global Logistics: Balanced Growth (Standard physics)

🟥 Food Tech: Safety Net Insurance (Grants a one-time emergency recovery jump)

Before (The Messy Conditional Branching) In the early prototype, changing styles required massive, hardcoded conditional branches. The game loop was a monolithic "spaghetti" function where physics, key inputs, and DOM rendering were all tangled together.

JavaScript
// BEFORE: Hardcoded nested logic inside startGame
function startGame(style) {
if(style === 'AI') {
jumpPower = -18 * (1 + marketBonus);
platWidth = 70;
styleLabel.innerText = "AIテクノロジー";
styleLabel.style.backgroundColor = "#3b82f6";
} else if(style === 'RE') {
// ... Repeated mud-style variables setting ...
}
}

After (The Copilot Glow Up) Using Copilot's architectural analysis, I refactored the entire codebase into a clean, Data-Driven Architecture using a central STYLE_CONFIG table and fully decoupled the game loops.

JavaScript
// AFTER: Clean, Data-Driven Architecture suggested by Copilot
const STYLE_CONFIG = {
'AI': {
name: "AI Technology",
color: "#3b82f6",
platColor: "#3b82f6",
gravity: 0.45,
jumpPower: -20,
platWidth: 70,
hasExtraLife: false
},
'RE': { /* Safe & Steady parameters / },
'LG': { / Balanced Growth parameters / },
'FT': { / Safety Net Perks */ }
};
How GitHub Copilot Helped (The Completion Arc)
GitHub Copilot wasn’t just a code generator; it acted as a senior architect that helped me cross the finish line by forcing me to focus on code quality over feature-creep.

The Architecture Audit:
I asked Copilot to review my original messy prototype. It instantly flagged that my style logic was scattered. It suggested migrating to STYLE_CONFIG, which immediately eliminated all raw if-else blocks from the game setup.

Decoupling the Monolith (Function Splitting):
The original loop() function was over 100 lines long, making it a nightmare to debug. Copilot guided me to split the responsibilities into clear, single-purpose modules:

handleInput() (Input handling)

updatePhysics() (State management)

checkCollisions() (Collision logic)

handleCameraScroll() (Viewport adjustment)

render() (Pure visual synching)

Eliminating Magic Numbers:
Copilot swept through the code and gathered all raw screen dimensions and hardcoded layout bounds into a unified GAME_CONSTANTS object, giving the game long-term maintainability.

Tech Stack
Python & Streamlit: Core web wrapper and page configuration.

HTML5 / CSS3: Retro-inspired arcade UI frame.

Vanilla JavaScript: Decoupled, state-driven 2D physics engine.

What I Learned
The GitHub Finish-Up-A-Thon taught me that finishing a project isn't about padding it with 100 raw features. It’s about polishing the core user experience and leaving the codebase cleaner than you found it. GitHub Copilot shined brightest when helping me refactor, structure, and modularize an old idea into a robust, scalable reality. Now, adding a new "Investment Style" to teach children about finance takes less than 10 seconds—just add a new row to the config table!

🗡️ Tsundoku Slayer: An Agent That Decides What Not To Read

sevasu — Sun, 31 May 2026 03:35:30 +0000

"Stop summarizing the noise. Start executing it."
Tsundoku Slayer is an autonomous agentic system powered by Hermes Agent that overnight patrols your unread tabs, mercilessly filters out 90% of the information overload, and saves only the information capable of killing your current blocker.

🎯 The Problem
While debugging a painful Streamlit IndexError, I realized my real issue wasn't a lack of information—it was too much information. I had documentation, API feeds, tech news, and bookmarks all competing for my limited focus.

Most AI tools try to "summarize" everything, which ironically generates more text to read and increases cognitive load. I didn't need another summarizer. I needed an autonomous agent capable of deciding what NOT to read right now.

🧠 How Hermes Agent Drives the Workflow
This project doesn't just scrape webs; Hermes Agent acts as a high-conviction decision maker. It coordinates the entire workflow by running a multi-step reasoning loop overnight.

⚙️ The Agent Workflow
Retrieve: Fetches unread article content via web scraping tools.

Compare: Ingests and cross-examines the content against the user's active, real-time problem context (e.g., specific stack traces).

Reason: Analytically evaluates the true relevance of the article to the current blocker.

Verdict: Produces a high-conviction binary choice: SAVE or EXECUTE.

Justify: Generates a crisp, logical explanation for why an article was terminated or spared.

Synthesize: Automatically crafts an immediately applicable Python/Streamlit code patch for saved items.

📋 Example Outcome: Focus in Action
Here is a real-world scenario of how Hermes Agent processes a chaotic backlog when you are stuck on a critical crash:

Current Blocker: IndexError: list index out of range inside a Streamlit dialogue array loop.

Unread Queue (Input):

Streamlit st.status Documentation ➔ EXECUTE (Irrelevant UI reference)

General Python Tag Feed ➔ EXECUTE (Too broad, pure noise)

Tech News Flash ➔ EXECUTE (Complete distraction)

Streamlit IndexError Bug Fix Guide ➔ SAVE (The Hidden Gem)

📊 The Dawn Execution Report
Noise Kill Rate: 75%

Generated Justification (for Saved Item): "Critical match: This guide outlines exactly why state sync delays cause index mismatches in Streamlit arrays."

Generated Actionable Patch (Output):

Python

Hermes Agent generated patch to kill the blocker immediately:

safe_idx = min(
st.session_state.current_index,
len(st.session_state.dialogue_list) - 1
)
current_dialogue = st.session_state.dialogue_list[safe_idx]
🛠️ Technical Implementation & The Sandbox Fallback
Frontend: Streamlit (Features a high-contrast agent dashboard and real-time reasoning visualization via st.status)

LLM Core: gemma4:e4b running locally via Ollama.

Key Metric: "Noise Kill Rate"—A prominent dashboard metric showing the exact percentage of data the agent successfully terminated, instantly communicating the saved cognitive load.

💡 Note for Judges (Demo Reliability)
To ensure a deterministic and reliable demo experience during judging, the current prototype includes fallback context boundaries for selected URLs within the scraping tool. This architecture is designed to transition directly into a dynamic vector-embedding pipeline (RAG) mapped against the agent’s core prompt structures.

🚀 The Core Philosophy
Most AI systems help people consume more information. Tsundoku Slayer focuses on a different question: "What information deserves your attention right now?"

Instead of generating another tedious report, Hermes Agent acts as an intelligent decision-making layer. It protects developer focus by filtering, prioritizing, and surfacing only immediately actionable knowledge.

[GitHub][https://github.com/sevasu77/tsundoku-slayer]

🏆 Inference Collapse: Real-Time Hallucination Audit

sevasu — Sun, 24 May 2026 01:29:18 +0000

🏆 Inference Collapse: Real-Time Hallucination Audit

Inference Collapse is a cyberpunk-inspired real-time simulation game that binds Gemma 4 (31B-it) inference outputs directly to downstream world-state behavior.
The project visualizes LLM hallucination, overconfidence, and unstable reasoning as physical threats, spatial corruption, and environmental instability inside an interactive game system.

💡 Project Overview

In this game, the player acts as an audit bot exploring corrupted sectors while monitoring inference signals generated by Gemma 4.

As reasoning quality degrades, the game world itself becomes unstable.

Structured inference signals from Gemma 4 are directly injected into gameplay logic:

confidence → enemy AI speed, field of view (FOV), and player visibility changes
severity → spatial glitches, coordinate noise, and world instability

This creates a real-time relationship between:

LLM inference → downstream world-state corruption

Rather than treating hallucination as a simple model failure, this project turns it into an interactive gameplay mechanic.

🧠 Why Gemma 4 (31B-it)?

This project intentionally uses Gemma 4 – 31B-it (Dense) because of three key advantages:

Strong reasoning consistency

To simulate believable hallucinated logic, the model needs to maintain coherent reasoning while still producing biased or unstable conclusions.
31B-it provided a strong balance between reasoning depth and output stability.

Structured JSON outputs

The game directly binds inference values such as confidence and severity into real-time physics and AI behavior.
Reliable structured output was essential for stable simulation updates.

Future local deployment potential

Although the current version runs through API-based inference, the architecture was designed with future local Gemma deployment in mind.

🛠 Technical Implementation
Backend
Python
Streamlit
Google GenAI SDK

Gemma 4 generates structured inference signals that are parsed and transformed into gameplay parameters.

Frontend
HTML5 Canvas
JavaScript

Using a real-time rendering loop, Gemma’s outputs are directly mapped into movement logic, visibility systems, and environmental distortion.

Inference Pipeline

Gemma output → JSON parsing → world-state binding → gameplay update

Fallback Mode

If API access becomes unavailable (degraded mode), the system switches to a local simulation fallback so reviewers can still experience the inference-driven mechanics.

🎨 Originality

This project redefines hallucination not as a passive AI error, but as:

Hallucination as a Gameplay Mechanic

False confidence, unstable reasoning, and contradictory outputs directly affect enemy behavior, visibility, and environmental corruption.

The goal was to create an experience where LLM reasoning quality itself becomes the difficulty system of the game.

GitHub: Inference Collapse

🧠Thought Navigation Engine

sevasu — Mon, 27 Apr 2026 08:57:41 +0000

Introduction: A Shift Beyond Performance

The most striking aspect of Google Cloud NEXT 2026 was not an incremental improvement in AI performance, but a fundamental redefinition of its role.

In particular, two announcements stood out:

Gemini Enterprise (a restructured evolution of Vertex AI)
The declaration of the “Agentic Era”

AI is no longer positioned as a system that simply answers questions.
Instead, it is being designed as an autonomous agent that executes tasks and workflows.

In other words, AI is shifting from a supporting intelligence to an acting entity.

This raises a deeper question:

If AI becomes something that acts, where does human thinking move?

The Core Question: Where Does Human Thought Go?

Gemini 3.1’s multimodal capabilities, TPU generation upgrades, and the Agentic Data Cloud all share a common direction:

They assume that AI is no longer just generating answers, but making decisions and taking actions.

This fundamentally changes the system architecture of intelligence.

At this point, the role of humans is no longer obvious.
Are we simply becoming instruction providers?

Or does thinking itself need to be redefined?

The Real Problem: Thinking Is Not a Skill Problem

Most people assume that “not being able to think” is a capability issue.

However, the real structure is different:

“I don’t know where to start thinking”
“My perspective gets stuck”
“Ideas don’t expand”

These are not skill failures.

They are system design failures.

Thinking does not fail due to lack of ability,
but due to lack of entry-point design.

Thinking is closer to an interface than a skill.

Thinking as Mode Selection

Thinking is not a single process.

It consists of multiple entry modes:

Analytical (decomposition and structure extraction)
Structured (relational organization)
Realistic (constraints and feasibility)
Positive (reinterpretation and reframing)

Thus, thinking is not defined by what you think, but:

which mode you start from

Proposal: The Thought Navigation Engine

Based on this hypothesis, I redefined AI not as a “response generator”, but as:

a layer that designs the starting point of human thinking.

Google Cloud NEXT 2026 introduced the “Agentic Era”, where AI operates as an autonomous actor in the external world.

This project explores the inverse direction:

autonomy in human internal cognition.

Four Thought Modes

This system models thinking as four distinct cognitive spaces:

Analytical: decomposes structure and causality
Structured: organizes relationships
Realistic: evaluates constraints and risks
Positive: reconstructs meaning

The user input is not treated as an answer request, but as a cognitive seed.

The AI selects the optimal mode and begins from that perspective.

🖼️ Before: Raw input state screenshot

Connection to Gemini Enterprise

This framework aligns with the direction of Google Cloud NEXT:

Gemini Enterprise → AI agents executing work
Agentic Era → AI as decision-making systems
Agentic Data Cloud → meaning-aware data infrastructure

These represent autonomy in the external world.

This project, however, focuses on:

autonomy in internal cognition

Thus, both systems form a symmetrical structure:

External autonomy (AI actions)
Internal autonomy (human thinking design)

🖼️ After: Mode-based cognition visualization screenshot

Implementation: Thinking as a Flow

The system is designed as a continuous process:

Input is received as a cognitive seed
A thinking mode is selected
The mode defines perspective constraints
Output is generated under that constraint
The result is visualized spatially

Importantly, judgment and generation are not separated.

They are treated as a continuous process.

Conclusion: From Answer Systems to Thought Design Layers

Google Cloud NEXT 2026 marks a transition:

From model-centric AI
to agent-based infrastructure.

The essence of this shift is:

AI moving from “thinking” to “acting”

This project explores the complementary direction:

designing where human thinking begins

If AI becomes the actor in the external world,
humans must redesign cognition in the internal world.

When these two layers connect, a unified system of thinking and execution emerges.

This prototype is only an initial step in that direction.

[GitHub:URL][https://github.com/sevasu77/cognitive_design]

🌍 EARTH CHAT — When Data Isn’t Enough 🏆 DEV Weekend Challenge Submission

sevasu — Fri, 17 Apr 2026 03:03:37 +0000

🌍 EARTH CHAT — When Data Isn’t Enough

🏆 DEV Weekend Challenge Submission

🔗 LIVE DEMO

👉 https://disaster-nhu2gvkqsvbwexuyuyrogc.streamlit.app/

⚡ One-line Concept

Climate data becomes a living system that reacts, breaks, and talks back.

🖼️ EXPERIENCE PREVIEW

1️⃣ First Contact

2️⃣ Interaction Phase

3️⃣ Consequence Phase

💡 Why This Exists

Most climate dashboards show numbers.

But numbers don’t create urgency.

So I changed the rule:

What if the Earth reacts instead of reports?

🧠 Core Idea

Earth Chat transforms environmental data into a living feedback system:

🌍 Earth reacts to user decisions
🌫️ Air pollution affects system stability
⚠️ Real-world PM2.5 influences “glitch behavior”
💬 Earth speaks back emotionally, not numerically

🎮 How It Works

User selects environmental policy
Earth state evolves in real time
Air quality modifies system behavior
UI shifts visually based on Earth’s condition
The system gradually becomes unstable or stable

🔬 Key Insight

Instead of:

PM2.5 = 42 μg/m³

We experience:

“The Earth starts to glitch when the air becomes toxic.”

🛠️ Tech Stack

Streamlit
Python
OpenAQ API
Session State Simulation
Dynamic CSS Animation

🎨 Design Philosophy

Data alone does not change behavior → emotion does
Dashboards should react, not just display
Climate change should be felt, not only read

🔮 Future Ideas

Global shared Earth state across users
Real-time disaster API integration
Multi-region simulation
Persistent world evolution over time

🧾 Closing Statement

This is not a dashboard.

It is an experiment in a single question:

What if environmental data could feel alive?

🐄 This Cow = Your Thought — THINK ENGINE v5.0

sevasu — Fri, 17 Apr 2026 02:25:23 +0000

🚨

Anti-Value Proposition

This does not optimize your workflow.
It does not give you better answers.
It does not even try to be efficient.

It simply lets you…
move your thoughts through space.

🌀 What is this?

A spatial thinking interface.
You navigate your thinking instead of writing it.

You don’t type and get answers.
You move a thought (🐄) through cognitive fields.

Each direction changes how the thought behaves.

Analytical → break it down
Structured → organize it
Realistic → ground it
Positive → reframe it

Somewhere between movement and silence…
something stabilizes.

📸 Screenshot 1 — Your thought enters the system

📸 Screenshot 2 — Your thought reacts to a mode

🎮 How it works
Use W / A / S / D to move
The 🐄 represents your active thought
Nodes react based on proximity
Lines = cognitive connections
Sound input affects system stability

Silence is not empty — it is structured thinking.

📸 Screenshot 3

🤡 Why did I build this?

“What if thinking wasn’t linear?”

Most tools force you to:

write
organize
optimize

This does none of that.

It lets you:

drift
collide
stabilize

Or not.

📸 Screenshot 4

🧠 Technical Details (unnecessarily serious)

Built with Streamlit
Custom HTML + Canvas rendering
Real-time spatial interaction system
Audio input used as noise signal
Dynamic node-weighted synthesis logic

🧪 Try it yourself

👉 [][https://prompt-structurizer-e7fnagz9ashqcqofkzm4zp.streamlit.app/]

(If it feels unclear, that’s intentional.)

💬 Final Thoughts

This might be:

a thinking tool
a broken interface
or just a cow walking through ideas

I’m not entirely sure.

❓ Question for you

What do you think the cow is actually doing?

Wrong answers only.

🐄 The Cow That Glitched Into Another Dimension (and never came back)

sevasu — Thu, 02 Apr 2026 11:25:28 +0000

🚨 Anti-Value Proposition

This project solves absolutely nothing.

It does not improve productivity.
It does not teach you finance.
It does not even properly explain itself.

It is simply… a cow walking home in 1984…
that accidentally enters another dimension.

🌀 What is this?

You control a cow.

That’s it.

Move left and right, and eventually you’ll find… something you probably shouldn’t.

A door.

After that, things get worse.

The sky turns red
The world glitches
The cow starts saying questionable things
There is no clear objective
There is no escape (probably)
🤡 Why did I build this?

I wanted to create something that feels like:

“Wait… what am I even looking at?”

Not everything needs to be useful.
Some things just need to exist.

🧠 Technical Details (unnecessarily serious)
Built with Streamlit (because clearly this is a serious enterprise tool)
Uses HTML + JavaScript canvas rendering inside Streamlit
Procedural movement system for infinite scrolling
Randomized dialogue system for existential cow thoughts
Glitch effects to simulate… instability? corruption? who knows
🐄 Features
Cow
Moving cow
Disturbed cow
Interdimensional cow
Existential cow dialogue
🎮 Try it yourself

👉 [URL][https://summer-of-84-cow-jzapvmcuzffgs3v4vqby4q.streamlit.app/]

(If it breaks, that’s part of the experience.)

💬 Final Thoughts

This might be the most over-engineered useless thing I’ve built.

And honestly… I’m not sure if I regret it.

❓ Question for you

What do you think is actually happening to the cow?

Wrong answers only.

Beyond Guilt: Opening Finance Through a Jumping Cow

sevasu — Tue, 31 Mar 2026 21:23:53 +0000

[Try it yourself][https://idlsd7wgwbvlpbctbjm5hd.streamlit.app/]

I didn’t start with a mission to democratize financial literacy.
I started with a cow that jumps when stock prices move.

At the time, finance felt distant to me.
Dense textbooks, unfamiliar terminology, and an unspoken sense that it belonged to “those who understand.”
Every time I encountered it, I felt like I was standing outside of something important—watching, but not really part of it.

And yet, the world clearly moves around it.
That distance stayed with me.

At some point, I stopped trying to “understand” finance,
and started thinking about how to feel it.

If the stock price goes up, the cow jumps higher.
If it drops, the jump becomes smaller.

That’s all.

But in that simple motion, there is something immediate and intuitive.
No need for charts, no need for terminology.
Even without explanation, you can sense the “mood” of the market just by watching the movement.

It feels less like studying, and more like playing.
And that shift—from obligation to curiosity—might be what keeps people from giving up in the first place.

I built this using Streamlit, a lightweight framework that runs entirely in the browser.
No expensive setup, no special hardware.
If you have a device and an internet connection, you can access the same experience.

There were limits to what I could build on my own.
For more complex JavaScript interactions, I turned to AI as a collaborator.

It wasn’t about replacing my role, but reshaping it.
I focused on designing the experience—how it should feel, how simple it should be—while letting AI assist with the parts I couldn’t fully implement myself.

That balance became part of the process.

This project will not change the world overnight.
But if somewhere, someone feels that finance is not something distant or intimidating—
but something slightly more approachable, even a little interesting—
then it has already done something meaningful.

We may not be able to eliminate the educational gap created by where we are born or how we grow up.
But we can lower the entrance, even just a little.

This jumping cow is a small attempt to do exactly that.