Simulating P2P Attacks and Teaching AI to Resume Sessions

TL;DR

It’s been one of those weeks where the terminal never really closed. I clocked 78 commits and pushed 4 PRs across 9 different repositories, maintaining a perfect 7-day streak. The bulk of the heavy lifting happened in the P2P space—specifically simulating network attacks—and adding some much-needed session persistence to my AI coding tool, nanocoder. With over 21,000 lines added and about 6,500 deleted, it was a high-output week focused on building out complex systems and then immediately refining them.

WHAT I BUILT

The star of the show this week was definitely P2P-Attack-Simulation. I’ve been obsessed with how decentralized networks handle adversarial conditions, and I finally merged a massive PR for Topology ts simulation. We’re talking 18,756 additions and 6,436 deletions. I essentially rewrote how the network topology is represented in TypeScript to make it more modular. Before, the simulation was a bit too rigid; now, I can spin up different node behaviors and see how the gossip protocols hold up when half the network starts acting malicious. It’s one thing to read about Sybil attacks in a paper, but seeing the message propagation latency spike in your own simulation is a different kind of satisfying.

Over in nanocoder, I spent a good chunk of time on the developer experience. If you’ve used AI coding assistants, you know the pain of losing context or having to restart a session from scratch. I implemented a new Feature /resume command to continue session. This involved a fair bit of state management (about 2,300 lines of code) to ensure that when you come back to a project, the AI knows exactly where you left off. It’s all about reducing friction. I want to spend my time coding, not re-explaining my file structure to a LLM.

I also dipped back into the low-level world with the networking repo. This is where I get my Rust fix. I merged two PRs here: one to Implement proper RST generation and another to refactor: remove timer module and associated functionality. The RST (Reset) generation is crucial for proper TCP handling—basically telling the other side "I have no idea what you're talking about, let's start over." The refactor felt great, too. I realized the custom timer module was overkill for what we needed, so I ripped out 137 lines of brittle code. Less code, fewer bugs.

Beyond the big features, I kept the wheels turning on several other projects. I pushed 10 commits to py-libp2p and 1 to dotnet-libp2p, mostly keeping the Python and C# implementations of the p2p stack in sync. I also spent some time tweaking my environment, with 8 commits to my nvim config (because a dev's work is never done when it comes to Lua plugins) and 7 commits to my notes repo, which is where I dump my raw thoughts on C and systems programming.

PULL REQUESTS

I managed to get four significant PRs merged this week, and they really tell the story of my transition from "building the foundation" to "polishing the experience."

The Topology ts simulation PR was the most exhausting but rewarding. It wasn't just about adding lines; it was about restructuring the entire simulation engine. I had to ensure that the TypeScript types correctly reflected the state of a peer at any given millisecond during an attack.

On the AI side, the Feature /resume command in nanocoder was a fun challenge in serialization. Making sure the session state could be saved and reloaded without losing the "vibe" of the conversation took a few iterations, but it's finally in a place where it feels seamless.

The Rust work in the networking repo was much more surgical. Implementing RST generation required me to get back into the weeds of packet headers, while the timer module refactor was a classic "addition by subtraction" move.

CODE REVIEWS

I only did one formal review this week, but it was a deep one. I looked at a PR for py-ipld-dag titled Add Block API, IPLD data model, codecs, registry, and tests.

I actually ended up requesting changes on this one. IPLD (InterPlanetary Linked Data) is the backbone of how we structure data in the p2p world, and the proposed implementation of the Block API felt a bit too coupled to specific codecs. I suggested a more registry-based approach to make it easier for others to plug in new data formats later. It’s important to get these base-level APIs right early on, or you end up paying for it in technical debt for years.

TECH STACK

This week was a true polyglot marathon.

TypeScript was my primary driver for the simulation work and the AI tooling. With over 15 million bytes of TS in my environment, it’s definitely my "get things done" language. But Python isn't far behind—especially with the work on py-libp2p and the IPLD reviews.

The Rust work in the networking repo reminded me why I love the language: the compiler is a jerk until you get it right, and then your code just works. I also touched some Lua for my Neovim setup and a bit of C for my personal notes and experiments.

My add/delete ratio was pretty high (21k vs 6k), which usually means I'm in a heavy feature-building phase. However, that 6k deletions in the P2P repo shows I'm not just piling code on top of code—I'm actively replacing the old stuff as I go.

And yeah, that 7-day streak feels good. It wasn't a forced grind; I just genuinely had something I wanted to solve every single morning when I woke up.

WHAT'S NEXT

Next week, I’m planning to take the P2P simulation even further. Now that the topology is flexible, I want to start implementing specific Eclipse attack scenarios to see how quickly a node can be isolated from the rest of the network.

I’m also keeping an eye on the feedback for the /resume command in nanocoder. There are probably some edge cases with large file buffers that I’ll need to iron out.

On the Rust side, now that RST generation is handled, I might start looking into better congestion control mechanisms for the networking library. There’s always more to optimize. See you in the commit logs!