If you’ve ever scrolled through Instagram comments on a popular account, you’ve probably seen them — spam comments promoting sketchy links, fake giveaways, or dubious services.

They show up everywhere. Celebrity accounts with millions of followers, niche hobby pages, even small creators. No matter where you go, spam comments are there.

But why? Instagram clearly has the resources to deal with this. So why do spam comments keep showing up?

How Instagram’s Built-in Filter Works

Instagram does have a comment filter. You can go to Settings → Comments → Custom Keywords and manually add words you want to block.

The mechanism is straightforward: it hides comments that exactly match the keywords you’ve registered.

Here’s the problem — you have to add each keyword one by one, and if the spam is written even slightly differently, the filter misses it entirely. Relying on exact keyword matching has a fundamental structural limitation.

How Spammers Beat the Filter

If you write the same word differently, the filter can’t recognize it. Spammers exploit exactly this.

In English, this might look like:

There are three main techniques:

Character substitution — Replacing letters with numbers or lookalike characters. free becomes fr3e. It reads the same to humans, but to the filter, it’s a completely different string.

Space/punctuation insertion — Adding spaces or dots between characters. click here becomes c.l.i.c.k h.e.r.e. Humans can still read it, but the filter sees a different word.

Invisible characters — Inserting zero-width Unicode characters in the middle of words. These are invisible to the eye but break string matching entirely.

When you block free gift, spammers just switch to fr3e g1ft. Block that too, and they find another variation. It’s an endless game of whack-a-mole.

Why No One Has Solved This

There are comment management services out there — CommentGuard, NapoleonCat, and others. But most of them rely on the same keyword-matching approach, just with a nicer UI on top.

For English spam, keyword matching works reasonably well since variations tend to be simpler. But for languages like Korean, spammers use far more sophisticated evasion techniques — splitting characters into their component parts (Korean characters are composed of individual consonants and vowels), inserting spaces within words, and using Unicode tricks.

Global services have little incentive to tackle these language-specific patterns. The result? Tools priced at $29–79+/month that still can’t catch non-English spam effectively.

So I Built One Myself

I got tired of watching spam flood the comments section.

The core idea is simple: instead of comparing text as-is, normalize it first. No matter how spammers disguise a word — character substitution, space insertion, Unicode tricks — normalization strips it back to the original form. Then the comparison catches it.

That’s how vybbi.io was born — an automated spam detection and removal service for YouTube and Instagram comments.

Right now, it focuses on spam detection. But the plan is to expand into catching negative and hateful comments using AI as well.

More on the journey coming soon. Thanks for reading!

Portfolio:

The Core Concept

Websites shouldn’t just be viewed; they should be felt. When we talk about “Awwwards-level” digital experiences, it isn’t just about a flashy color palette or a trendy typeface. It’s about that organic flow-the thin line between a static UI and an immersive environment.

The Vision: Motion-First Identity

My portfolio (screenshot above) is built on a single principle: Interfaces that feel alive – not just animated. In this hero section, I focused on three pillars to define my digital identity:

The Living Core: The central organic blob isn’t a pre-rendered video or a simple loop. It’s a performance-driven shader designed to give the interface a “pulse” that responds to the environment.

Typography & Hierarchy: By using high-contrast, minimalist Sans-Serif, I let the message breathe while the motion does the heavy lifting.

Technical Sophistication: Every interaction is locked at a cinematic 60FPS to ensure the premium feel remains buttery smooth.

The Creative Tech Stack

To bridge the gap between functional UI and high-end aesthetics, I utilized a stack that balances performance with creative freedom:

• Next.js: For a robust, SEO-friendly architecture.
• React Three Fiber (R3F): Bringing 3D into the DOM with seamless state management.
• Custom GLSL Shaders: Crafting unique visual textures that go beyond standard CSS.
• GSAP & Framer Motion: For orchestrating complex layout transitions and micro-interactions.

Beyond the Code

For me, code is more than just logic-it’s a medium for Digital Architecture. As a Creative Frontend Developer and WebGL Specialist, I am constantly pushing the boundaries of how we interact with the web.

The goal is always the same: Move away from “templates” and toward “experiences.”

I’d love to hear from other creative engineers:
How do you balance heavy WebGL graphics with web performance? Let’s discuss in the comments!

The Agent Reproducibility Paradox: Debugging Non-Determinism in Production

Your production agent made a decision that broke something. A user reports a weird output. A compliance audit flags unexpected behavior. You investigate.

You grab yesterday’s logs. Same prompt, same tools, same input. You replay it locally. Different output.

Welcome to the agent reproducibility paradox.

The Root Problem: Agents Aren’t Deterministic

Traditional software bugs are deterministic. Same input + same code = same crash, every time. This is why debuggers work: you can reproduce the exact state, step through execution, find the bug.

Agents don’t work this way.

Consider a single agent API call:

Input prompt: "Process this transaction"
Model: Claude 3.5 Sonnet
Temperature: 0.2
Available tools: [payment_api, audit_log, fraud_check]

Yesterday, this returned output_a. Today, same prompt, same config:

• The model version updated (Anthropic released a patch)
• The temperature seed drifted (framework version changed)
• The context window shrank (you added more system prompt)
• The tool response latency changed (payment API slowdown)
• Token encoding shifted (model training data evolved)

Now you get output_b.

Both are “correct” given the current system state. But they’re different. And you can’t reproduce output_a anymore because the system that produced it no longer exists.

Why This Breaks Debugging

Deterministic debugging works because:

1. You identify the problem
2. You reproduce it locally
3. You step through execution with a debugger
4. You find where state diverges from expected
5. You fix it

Non-deterministic systems break this cycle:

1. You identify the problem (user reports output_b broke something)
2. You try to reproduce it (can’t—model updated)
3. You look at logs (they show parameters, not execution details)
4. You check tool responses (they’re cached summaries, not raw data)
5. You give up (ship a hotfix, hope it works)

This isn’t speculation. This happens every week in production AI teams.

Engineer A: “Agent returned false for is_fraud_check_passed(). Spent 2h debugging. Turned out the fraud_check API had a one-minute outage. By the time I investigated, the API recovered. The agent was right, the system state was unstable, and logs didn’t capture it.”

Engineer B: “Same prompt, exact same tools, returns different classifications today vs yesterday. No code changes. Model had a micro-update. Context window is now 3 tokens shorter. Spending days trying to figure out if the agent broke or if the system did.”

Engineer C: “Compliance audit asks: prove your agent followed rule X yesterday. I have logs that show the agent saw the rule and processed the transaction. But the rule was ambiguous. The model interpreted it one way. The log can’t prove the interpretation was correct or incorrect. Just that it happened.”

Why Non-Determinism Matters More for Agents

In monolithic systems, non-determinism is rare and usually a bug. In agent systems, it’s fundamental.

Your agent:

• Calls 5+ different APIs (each has variable latency, variable response format)
• Processes variable-length context (different conversation histories)
• Uses temperature/sampling (inherent randomness in language generation)
• Delegates to multiple sub-agents (each adds more entropy)
• Relies on external state (databases, services, market data)

Each of these adds non-determinism. Together, they mean:

The probability of reproducing exact execution is approximately zero.

For compliance, this is catastrophic. EU AI Act Article 6 requires AI systems to maintain audit trails. But you can’t maintain an audit trail for execution that you can’t reproduce.

Regulators ask: “Prove your agent didn’t discriminate against this applicant.”

You show logs. They ask: “But can you reproduce the exact decision today?”

You can’t. Model updated. You show logs again. They say: “Logs are claims made by your system. We need proof witnessed by someone without stake in the outcome.”

You’re stuck.

What Reproducibility Actually Requires

Real reproducibility isn’t “same input → same output.” It’s “prove this exact execution happened as logged, at a specific time, without tampering, witnessed by a party that can’t deny it.”

Three requirements:

1. Cryptographic capture of execution — Every step (model call, tool invocation, response, decision) is timestamped, hashed, and signed at execution time. Not logged afterward (logs can be edited). Captured live.

2. Independent witness — A third party observes and attests to the execution. Not you (you have motive to edit). Not the model provider (they have motive to hide issues). A party with legal liability for false claims.

3. Proof you can’t forge — Signatures, hashes, timestamping using infrastructure you don’t control. If you try to alter the execution record, the tampering is cryptographically detectable.

Example: Your agent calls payment_processor.charge() with amount €100.

Without reproducibility proof, you log:

agent_id=123, action=charge, amount=100, response=success

With reproducibility proof, an independent witness timestamps and signs:

Time: 2026-03-20T14:32:17.451Z
Call: POST /payment_processor.charge(amount=100)
Request hash: a7f2e9d... (SHA256)
Response: success
Response hash: f1b4c2e... (SHA256)
Witnessed by: trust_layer_v1.2.5
Signature: MIIDe9w... (RSA-2048, key_id=tl_prod_2026)

Now you can prove the call happened exactly as logged, at a specific time, witnessed by infrastructure that can’t deny it.

Tomorrow, if regulators ask: “Did your agent charge €100 at 14:32:17 UTC?” You show the witness signature. They verify the signature against the public key. The signature is cryptographically valid. The agent charged exactly what it claimed.

You can’t produce a fake signature (you don’t have the private key). The witness can’t deny it (the signature is their legal attestation).

That’s reproducibility that holds up in court.

Why Logs Aren’t Enough

You might think: “Can’t I just log more detail?”

No. Here’s why:

Logs are claims made by the system that performed the action. Your agent logs what it did. Your payment processor logs what it processed. Your database logs what it committed. But logs are created by the parties with motive to hide problems.

If your agent made a mistake, it won’t log the mistake—it logs success.
If your payment processor had a bug, it won’t log the bug—it logs the transaction.
If your compliance team wants to hide a violation, they won’t log the violation.

Logs are useful for internal debugging. They’re insufficient for compliance, audit, or legal disputes, because they’re self-serving.

Proof requires a third-party witness that observed the system’s behavior and certified it. The witness can’t lie (cryptographic proof) and can’t deny it (legal liability).

The Multi-Agent Amplification

Single-agent systems have one layer of non-determinism. Multi-agent systems multiply it.

Agent A queries Agent B. Agent B queries your API. Agent C synthesizes their outputs. An orchestrator delegates to Agent D. Each step:

• Agent A’s output depends on model state, temperature, context length
• Agent B’s response depends on its own non-determinism plus what it received from A (which might be corrupted)
• Your API’s response depends on database state, cache state, load
• Agent C’s synthesis depends on how it interpreted A and B’s outputs
• Orchestrator’s delegation depends on all of the above

With n agents, you have n sources of non-determinism plus n opportunities for misinterpretation.

Proving execution required proving all n agents’ behavior. Logs won’t do it. Self-attestation won’t do it. You need n independent witnesses.

The Solution: Reproducibility as System Boundary Function

Reproducibility isn’t something your agent can solve alone. Your logging framework can’t solve it. Your orchestrator can’t solve it.

It requires an independent verification layer that:

• Observes all agent execution (API calls, model invocations, responses)
• Timestamps and signs everything at execution time
• Can’t be tampered with by agent code or application logic
• Provides cryptographic proof verifiable by external auditors

This layer sits outside your agent, outside your infrastructure, outside any single provider’s control.

When your agent runs, the verification layer watches:

1. Agent sends request to Claude API
2. Witness timestamps, hashes request
3. Claude returns response
4. Witness hashes, signs, timestamps response
5. Witness stores proof in immutable ledger
6. Agent continues execution

Later, auditors can verify:

• The exact request and response (cryptographic hash)
• The exact timestamp (3rd-party authority)
• The signature validity (witness’s public key)
• The ledger immutability (cryptographic chain)

Your agent doesn’t need to change. The verification is transparent.

Implications for Your Team

1. You can now reproduce execution — Not by running the same code (model may have updated), but by showing the witness signature. Auditors can verify the proof without trusting you.

2. Multi-agent complexity becomes auditable — Each agent’s behavior is independently witnessed. No single point of trust.

3. Compliance moves from “our logs show we’re compliant” to “here’s our witness proof of compliance.” These are different legal positions.

4. You can debug production incidents with real data — Instead of “logs show parameter X was Y,” you have “witness proof shows parameter X was Y at timestamp T with response Z from service W.” No ambiguity.

The Takeaway

Your agents can’t be deterministic. But their execution can be verifiable.

Logs won’t satisfy regulators. Proof will.

Start thinking about reproducibility not as “same input = same output,” but as “I can prove this execution happened exactly as claimed, witnessed by infrastructure I don’t control, using cryptography I can’t forge.”

That’s what enables AI agents to scale into regulated environments.

I Was Writing 4 Redux Functions for Everything… Until Redux Toolkit Changed It

When I first started learning Redux, I thought this was just how things worked.

If I needed to manage a simple feature, I had to write:

• Action types
• Action creators
• Reducers
• Store configuration

At first, it felt “professional”.

But after a few days, it started to feel… repetitive.

And honestly, a bit exhausting.

The Problem With Classic Redux (From My Experience)

Let me be real.

Redux is powerful. No doubt.

But as a beginner, I kept asking myself:

Why do I need so much code just to update a simple state?

For one feature, I was jumping between multiple files:

• actions.js
• reducers.js
• store.js

And inside those files:

• writing constants
• writing functions
• writing switch cases

It felt like I was doing the same thing again and again.

Then I Discovered Redux Toolkit

Today, I finally spent time understanding Redux Toolkit.

And this is where everything started to change.

Redux Toolkit is basically the modern way of writing Redux.

It removes the unnecessary complexity and keeps the power.

The Moment That Changed Everything

There were two functions that completely changed my understanding:

1️⃣ configureStore

Before:

I had to manually use:

• createStore
• combineReducers
• applyMiddleware

Now:

Just one function:

const store = configureStore({
  reducer: rootReducer,
});

That’s it.

Everything is handled internally.

No extra setup.

2️⃣ createSlice

This one honestly surprised me.

Before, I had to write:

• action types
• action creators
• reducers

Separately.

Now:

const counterSlice = createSlice({
  name: "counter",
  initialState: { value: 0 },
  reducers: {
    increment(state) {
      state.value++;
    },
  },
});

And just like that:

• actions are created automatically
• reducer is created automatically

One function replaces 3–4 things.

The Best Part: Cleaner Code

What I really liked is how clean everything feels now.

• No switch statements
• No scattered files
• No repeated boilerplate

Everything lives in one place.

And for the first time, Redux felt… simple.

A Small But Important Realization

Another thing I learned today:

You don’t have to switch everything at once.

You can use:

• classic Redux
• Redux Toolkit

in the same project

And both connect to React in the same way.

That means you can migrate step by step.

No pressure.

What I Learned Today

Today wasn’t about building something big.

It was about understanding:

How to write better Redux code.

How to reduce unnecessary complexity.

How to focus more on logic instead of boilerplate.

Final Thoughts

Before today, Redux felt like a lot of work.

After understanding Redux Toolkit, it finally started to feel practical.

If you’re learning Redux right now, my honest advice:

Don’t just learn classic Redux.

Learn Redux Toolkit early.

It will save you time, energy, and a lot of confusion.