DEV Community: KUSHAL BARAL

Creativity Is Theft. And Nature Stole First.

KUSHAL BARAL — Thu, 07 May 2026 14:41:57 +0000

Let me ask you something weird.

Why does the human brain look like a neural network?

Not metaphorically. Actually. Literally. The thing we built and called "artificial intelligence" — the thing we're all losing sleep over — looks suspiciously like the thing already sitting inside your skull. Neurons firing. Weights adjusting. Patterns recognizing patterns. Learning from data. Getting better over time.

We didn't invent that. We copied it. And then we called it innovation.

It doesn't stop at the brain either.

The camera? That's an eye. Lens, aperture, light hitting a surface and creating an image. We looked at the human eye and said "yeah we want that" and spent centuries trying to build it out of glass and metal.

Sonar? Bats had it first. We just figured out how to put it in submarines.

Flight? Birds. Obviously. The Wright brothers didn't sit down and think from scratch. They watched things that already flew and asked "what if we did that but with wood and fabric?"

Velcro was invented by a guy who kept getting burrs stuck to his dog's fur.

The whole field of biomimicry exists because at some point engineers collectively admitted — nature figured this out already, let's just copy it.

So here's the uncomfortable question.

Is human creativity actually just... really sophisticated theft?

Okay stay with me here because this is where it gets interesting.

Now science will tell you — nature didn't design any of this intentionally. No plan. No intention. Just random mutations and survival. And maybe that's true.

But honestly? When I sit with that explanation something feels off to me.

Like — the eye. Think about the eye for a second. Something that detects a single photon of light. That adjusts in real time. That self repairs. That runs on almost zero energy. That connects directly to the most complex thinking machine we've ever encountered.

And we're supposed to believe that just... stumbled into existence?

I'm not saying it didn't. I'm not smart enough to say that. I'm just saying — when I look at how perfect these solutions are. How every answer was already there before we thought to ask the question. It doesn't feel like accident to me. It feels like something was already trying to be understood.

Over millions of years. Through billions of failures. Through creatures that couldn't see well enough dying before they reproduced and creatures that could see slightly better surviving just long enough to pass that slight improvement forward.

Evolution is just iteration with death as the feedback loop.

And what came out the other side? The most optimized, elegant, efficient solutions to problems that we are still — with all our intelligence and technology — struggling to fully replicate.

The brain runs on roughly 20 watts of power. Your laptop charger uses more energy than the most complex thinking machine ever created. A bird's bone structure is so optimized for weight and strength that aerospace engineers still study it.

Nature had billions of years and infinite iterations and the strictest possible quality control — if it didn't work, it died. Of course what survived is optimal. Of course we keep copying it. What else would we copy?

So back to AI.

When we built neural networks we weren't being clever. We were being honest. We looked at the only working example of general intelligence we had — the human brain — and we said "let's start there."

Convolutional Neural Networks that power image recognition? Directly inspired by how the visual cortex processes information. The way your brain doesn't look at an image all at once but breaks it into edges, shapes, patterns, then assembles them — CNNs do exactly that.

Reinforcement learning? That's just evolution again. Try things. Reward what works. Punish what doesn't. Repeat until something intelligent emerges.

Transformers, attention mechanisms, the whole architecture behind ChatGPT and everything like it — it's all trying to approximate something the brain does naturally, effortlessly, while also somehow remembering to breathe and regulate your heartbeat at the same time.

We are not building artificial intelligence. We are building a very early, very rough, very power hungry draft of what nature already perfected.

And here's where the philosophy hits.

If we copied nature. And nature copied nothing because nature invented the template. Then what is originality actually?

Picasso said "good artists borrow, great artists steal." But nature didn't even steal. Nature just ran the algorithm long enough that something extraordinary fell out the other side.

Maybe that's what creativity actually is. Not thinking of something from nothing. Nobody does that. Nothing comes from nothing.

Maybe creativity is just iteration with taste.

You take what exists. You combine it differently. You run it through your own specific set of experiences and failures and weird 2am thoughts. And something comes out the other side that didn't exist before. Not because you invented from zero. But because you are a specific, unrepeatable combination of everything you've ever absorbed.

Just like evolution. Just like nature. Just like the neural network sitting in your skull right now reading these words and deciding whether they mean something.

So is AI creative?

It was trained on everything humans ever made. Every book. Every image. Every pattern. Every idea. It iterates. It combines. It produces something that didn't exist before.

Sounds familiar right?

The difference — and maybe this is the only difference that matters — is that AI doesn't have a why.

Nature iterated because death was the alternative. Humans create because something inside us reaches toward meaning. Because we feel things. Because we're trying to say something to someone. Because we're afraid of being forgotten. Because we love someone and don't know how else to say it. Because we're confused about being alive and making something feels like an answer even when it isn't.

AI creates because you asked it to.

That gap — between creating because you must and creating because you were prompted — might be the last real distinction worth talking about.

And maybe this is just me thinking out loud. Maybe this is where the science ends and something else begins.

But when I look at how perfectly optimized nature is. How every solution was already there before we thought to look for it. How we keep arriving at the same answers from completely different directions.

It feels less like random accident to me. And more like something was already trying to be understood.

Maybe evolution isn't nature figuring things out. Maybe it's something figuring itself out. Through nature. Through us. Through whatever comes next.

Every tradition, every belief system, every culture that ever existed — they all pointed at something like this. Just with different words. Different stories. Different names. We rebranded it as science. And forgot to ask if they were describing the same thing all along.

But that's just what I think. I'm not asking you to agree. I'm just asking you to sit with it.

So here's my question for you.

If creativity is just sophisticated iteration — if nature iterated blindly, humans iterated with feeling, and AI iterates with data — at what point in that chain did something genuinely new actually enter the world?

Or did it never? Was it always just the same thing learning about itself through different shapes?

I genuinely don't know. Tell me what you think.

This was written with AI. But the question kept me up at night long before I typed the first prompt. So whose thought is it really? Maybe that's just another version of the same question.

Haul :) a tiny file organizer daemon for Linux

KUSHAL BARAL — Sat, 25 Apr 2026 11:21:47 +0000

I hate messy Downloads folders. You know the feeling:

report.pdf
report(1).pdf
report(2).pdf
screenshot.png
screenshot(1).png
screenshot(2).png
video_final.mp4
video_final_FINAL.mp4
notes.docx
notes_copy.docx
notes_copy_FINAL(1).docx

At some point you just stop caring and let it rot.

Cron jobs felt overkill — why poll every minute just to watch an empty folder? So I built haul. Drop a file in a watched folder, it moves it to the right place. That's it.

The trick — zero CPU when idle

haul uses inotify, a filesystem event API built into the Linux kernel. Instead of running a loop, it just waits for the kernel to say "hey, a file arrived" — sorts it — then exits. systemd restarts it immediately for the next file.

No polling. No persistent process. Nothing running between events.

file lands
    ↓
kernel fires inotify
    ↓
haul wakes up
    ↓
file sorted → ~/Data/subfolder
    ↓
haul exits
    ↓
systemd restarts it
    ↓
(waiting for next file...)

Install

sudo apt install inotify-tools -y
curl -fsSL https://raw.githubusercontent.com/kushal1o1/haul/main/install.sh | bash

Usage

haul install      set up and start
haul sweep        sort files already sitting in watched folders
haul start/stop   manage the service
haul logs         tail the live log
haul uninstall    remove haul (your ~/Data/ is untouched)

What it sorts

Folder	Extensions
PDFs	`.pdf`
Images	`.jpg` `.jpeg` `.png` `.gif` `.webp` `.svg`
Videos	`.mp4` `.mkv` `.avi` `.mov` `.webm`
Audio	`.mp3` `.flac` `.wav` `.ogg` `.m4a`
Code	`.py` `.js` `.ts` `.sh` `.json` `.yaml` `.sql`
Zips	`.zip` `.tar.gz` `.rar` `.7z` `.deb`
WordFiles	`.doc` `.docx` `.odt`
Excel	`.xlsx` `.xls` `.csv`
Others	everything else

Screenshots are detected by source folder, not filename — set SCREENSHOTS to wherever your tool saves them.

Fully configurable

Everything — watched folders, destination, subfolder names, extension rules — is just bash variables at the top of ~/.local/bin/haul. Open it in any editor and change what you want.

DATA="$HOME/Files"          # change destination
DOWNLOADS="$HOME/Desktop"   # change watched folder

After editing: haul restart

Duplicate handling

Same file arrives again → deleted silently
Same name, different content → renamed with a timestamp before moving

Logs

[2024-01-15 14:30:22] MOVED report.pdf → ~/Data/PDFs/
[2024-01-15 14:31:45] DUPLICATE (identical) skipped: report.pdf
[2024-01-15 14:32:10] CONFLICT renamed: notes_20240115_143210.md

Requirements: Linux with systemd, bash 4+, inotify-tools. Tested on Ubuntu 22.04 / 24.04.

Source: github.com/kushal1o1/haul — MIT licensed.

If you've been living with a messy Downloads folder, give haul sweep a try first — it sorts whatever's already there without touching the daemon.

Real MCP has a lot going on - but the core idea is this simple

KUSHAL BARAL — Tue, 21 Apr 2026 17:18:37 +0000

MCP (Model Context Protocol) is everywhere right now. Claude uses it, Cursor uses it, a ton of AI tooling is being built on top of it. There's an official SDK, servers, transports, capabilities negotiation... it can feel like a lot.

But when I actually dug into what MCP is doing at its core, I realized — it's just structured JSON going back and forth. That's the whole idea. So I built a minimal version from raw Python, no libraries, to make sure I actually understood it before touching the real thing.

What MCP actually is

Strip away the SDK and the spec details — here's the mental model:

a server exposes tools (functions an AI can call)
a client discovers those tools and calls them by name
everything is JSON, every message has a predictable shape

The real MCP spec adds things like capability negotiation, resource types, prompt templates, SSE transport, and more. But that core loop — client asks, server responds with a tool result — is the same.

Think of it like HTTP but designed specifically for AI agents calling tools. The protocol exists so any agent can talk to any server without needing custom glue code.

What I built to understand it

Two versions, zero external dependencies — just Python stdlib:

Basic version — the absolute minimum:

client sends a JSON request
server reads it from stdin
server runs a tool
server replies with JSON on stdout

Richer version — closer to real MCP, adds a JSON-RPC style flow:

initialize — handshake, server returns its name and version
tools/list — client asks what tools exist
tools/call — client calls a tool by name with arguments

That three-step flow is basically what happens every time an AI agent connects to a real MCP server.

How a protocol works (the bit no one explains)

Two processes agree on a message format, then just talk. That's it. In this case:

the server sits there reading stdin line by line
the client writes one JSON object per line, reads one JSON response back
no sockets, no framework — just text in an agreed shape

Real MCP uses stdio transport for local servers and SSE for remote ones. Same idea, just fancier plumbing.

Try it

python3 basic-mcp-server.py

Type a raw request:

{"tool": "say_hello", "arguments": {"name": "bro"}}

Get back:

{"result": "Hello bro"}

No library. No magic. Just Python reading and writing JSON — same as what the real SDK wraps.

Full code here → https://github.com/kushal1o1/Mcp-basics

Now I want to build an actual MCP module on top of this foundation — something useful, something real. A devtool? A workflow helper for AI agents?

Drop your idea in the comments — what MCP module should I build next? I'll pick the most interesting one and document the whole thing.