Aayush Giri

devrel travel looks glamorous from the outside, you see pics like this and think “damn, nice life” but here’s the thing, this job requires you to talk. a lot. workshops, talks, twitter spaces, 1:1s with devs, answering the same questions with the same energy every single time and it only works if you genuinely love it. like actually love explaining how things work to people because if you don’t, you’re just performing enthusiasm for a paycheck. and developers can smell that from a mile away the perks are real. the views are beautiful. but so is the energy it takes to stay “on” when you’re exhausted as uncle ben once told my friend spiderman - with great power comes great responsibility this has to be a passion. otherwise you’re just working to work.

the mempool sees all and judges quietly.

i keep coming back to one number from the openhuman writeup: it can do thousands of small memory recalls a day for under a dollar. that's the line that actually matters. not the mascot, not the demo. cost. because the difference between an agent that's a toy and an agent that's infrastructure is whether it can afford to think constantly in the background instead of only when you poke it. cheap recall means an agent can have something like a subconscious - a loop that's always running, always reconsidering, always cheap enough to leave on. we spent the last two years obsessed with how smart models are. the next two are going to be about how cheap it is to let them think when nobody's watching. that's the unlock. that's the whole game. github.com/tinyhumansai/o… @tinyhumansai @senamakel

i write rust to be safe and solidity to be brave.

every protocol is decentralized until you check who owns the upgrade key.

i've started treating my agent setup like a codebase, not a chat. prompts get versioned. context gets organized into files. workflows get named and reused. the people still typing one-off messages into a box are about to feel like they were SSH-ing into prod by hand while everyone else wrote deploy scripts. the tooling layer always wins. it just takes a year for people to notice it formed.

onchain is just "in public, forever, with receipts" and somehow we made that sound cool.

gm!

AI-native is the most abused phrase in tech right now so here's the test i actually use: remove the model. if you still have a coherent product, you built a normal app and taped a copilot on. if the whole thing collapses into nonsense, congrats, it's AI-native. openhuman isn't AI-native because it talks to you in a cute mascot. it's AI-native because "ingest two years of your gmail, compress it 80%, and rebuild a memory tree every 20 minutes" is a sentence that was physically unbuildable three years ago. the model isn't a feature bolted to the side. the model is the only reason the architecture exists. that's the line. most things claiming to be on the far side of it are not. github.com/tinyhumansai/o… @tinyhumansai @senamakel

every onchain bug i've ever seen had the same root cause dressed in different clothes: someone assumed an order of operations that an adversary was paid to violate. that's the whole genre. you don't audit code, you audit assumptions. the code is just where the assumptions go to get exposed.

the internet rewards being early and being right but it really rewards being early, wrong, loud, and then correcting yourself in public. that's not a flaw in the algorithm. that's just learning, sped up and made legible. the people afraid to be wrong on the timeline are also the people learning the slowest. shitpost is just hypothesis with worse grammar.

i think we're going to look back at "prompting" the way we look back at typing addresses into a browser bar by hand. a transitional skill. necessary for now, embarrassing later. the actual durable skill underneath it isn't wording, it's specification - being able to describe what you want with enough precision that an unfamiliar mind, human or model, can execute it without you in the room. that skill is ancient. it's what good PMs have, what good tech leads have, what good API designers have. AI just made it suddenly, brutally measurable. you find out instantly whether your spec was clear, because something tries to build it in fifteen seconds. the feedback loop on clear thinking just got a thousand times tighter. it's not that machines got smart. it's that vagueness got expensive.

the most honest moment in building anything is the first time a stranger uses it wrong. not maliciously, just differently than you imagined. every wrong click is a tiny lecture about an assumption you didn't know you'd made. i've learned more from confused users than from any spec doc i've ever written.

"move fast and break things" but the things are smart contracts so maybe move medium.

my git history is a confession written in the present tense.

the convergence everyone keeps predicting between AI and crypto isn't a product, it's a question, and the question is: who do you trust to run an autonomous thing that touches your money? crypto's answer was "no one, verify everything, here's the math." AI's answer so far has been "trust the lab, it'll be fine." those two cultures are about to collide hard, because the moment an agent can move funds, sign a transaction, or rebalance a position, "it'll be fine" stops being acceptable and "here's the math" becomes load-bearing. i think the most important crypto work of the next few years won't look like crypto at all. it'll look like giving agents verifiable boundaries, proofs of what they did, not promises about what they will.

every "quick refactor" is a portal to a different codebase.

gm! gm!

glamsterdam is @ethereum 's biggest upgrade since the merge. two headliner EIPs, both hitting H1 2026: EIP-7732 (ePBS): the vast majority of ethereum blocks are built by offchain relays with zero cryptographic guarantee. trusting a middleman. on a trustless chain. ePBS moves this INTO the protocol. builder posts signed bid onchain. ethereum enforces it. relay trust gone. propagation window expands from 2s → 9s. EIP-7928 (BALs): ethereum currently doesn't know what state a transaction needs until it runs. so it processes txs one at a time. sequentially. waiting on disk reads. BALs flip this: declare state access upfront in the block header. non-conflicting txs execute in parallel. result: → simple ETH transfers up to 71% cheaper (EIP-2780) → foundation for parallel execution at L1 → trustless block building, no relay dependency → larger blocks, more blob capacity for L2s devnets are live. testnets coming this spring. ethereum L1 is not a bottleneck anymore. it's becoming the throughput layer.

the isolation of being interested in things none of your non-tech friends understand or care about. enthusiasm without audience :)

watching your old code and cringing at every line. growth is embarrassing in retrospect.