Tag:rust
All the posts with the tag "rust".
532 Commits in One Day: What Multi-Agent Sessions Reveal About Security and Debugging
A single day with 11 parallel agent-doc sessions produced 532 git commits across bug fixes, correspondence, and feature development. The debugging session alone took 292 commits to untangle snapshot rollbacks, duplicate writes, and session lifecycle failures. Here's what dog-fooding an agentic tool teaches you about multi-user security and complex debugging.
The lazily Architecture: One Reactive Graph from Local Memory to the Network
A full-architecture tour of lazily — the reactive core (Context, Cell, Slot, Signal, Effect), the three execution contexts (single-threaded, thread-safe, async), the Snapshot/Delta wire protocol that carries the same graph state across IPC, WebSocket, WebRTC, and FFI, and the cross-language family. With use cases and diagrams.
Building Agent-Doc: Live Debugging tmux Race Conditions & CRDT Document Sessions
A live coding session working on agent-doc, corky, and tmux-router — covering Google OAuth app verification, tmux pane proliferation debugging, CRDT document session management, and markdown AST parsing.
Ep5: Preflight & Browser Extension — Skill to Binary Series
YouTube comment automation research, designing the preflight command, fixing the IPC boundary reposition bug, and planning a browser extension for platform automation.
Dog-fooding agent-doc Part 2: rmemo, tag-path, and Releasing v0.16.1
A live session walking through agent-doc's compaction workflow, showcasing rmemo — a 358-byte reactive JavaScript library, introducing tag-path semantic code search with TreeSitter, and shipping agent-doc v0.16.1. Reflections on vibe coding, race conditions, and why naming conventions matter.
Skill to Binary: Debugging agent-doc Live — 6-Part Mini-Series
A 7.5-hour live coding mini-series documenting the migration of agent-doc's boundary management from the Claude Code skill into deterministic binary/plugin code — and the cascade of bugs discovered along the way.
Dog-fooding agent-doc: CRDT Debugging, Reactive Architecture, and Why God = Existence
A 2-hour live session debugging CRDT merge bugs in agent-doc, a Rust CLI tool for structured AI conversations in markdown. Covers reactive stream architecture, Existence Lang ontology, and what vibe coding actually looks like.
Existence-Lang: Pneuma, Noumena & Phenomena in Software Ontology
A deep dive into existence-lang ontology development — building a formal language for modeling reality in software systems. Explores pneuma, noumena, phenomena, universal applicability, precision as possibility space, and permaculture as systemic design.
Building Agent Resume: AI-Powered Job Search Workflow with Resume Generation
A live coding session building agent-resume — a TOML-based system for generating tailored resumes for job applications, phone call transcriptions, and email correspondence using corky and agent-doc.
Slot → Cell → Signal: Composing Lazy and Eager Reactivity in One Graph
How lazily-rs composes three primitives — Cell, Slot, and Signal — so you can pick lazy (compute-on-read) or eager (recompute-on-change, no unset window) per derived value inside a single dependency graph. With use cases and diagrams.
Module Harness, Back-Testing, and Building a Domain Ontology with Agents
A live session exploring module-level harness context for agent-doc, back-testing concepts for evaluating harness effectiveness, agent teams vs organic architecture, and the first real usage of existence language to build a domain ontology — with the agent defining its own terminology.
Ep2: The Snowball Bug — Skill to Binary Series
Moving boundary management into the binary reveals a cascading corruption bug. Conditional reinsertion causes each cycle to perpetuate a missing boundary. Also: AI agents as probabilistic algorithms and context window optimization.
Ep6: Deterministic Primitives — Skill to Binary Series
The design principle that emerged: put deterministic operations in the binary, let agents handle probabilistic coordination. Session wrap-up and reflections on AI-assisted development velocity.
Dog-fooding agent-doc Part 3: YouTube Upload in Rust, tmux-router Tests, and JetBrains Plugin IPC
Building developer tools live with AI — implementing YouTube's resumable upload protocol in Rust, writing 61 tmux-router tests, wiring JetBrains plugin IPC for real-time document patching, and reflections on chaos, consciousness, and vibe coding.
Agent-Doc: Building a Cross-Platform FFI Plugin with Socket IPC
Live session replacing file-based IPC with cross-platform socket communication in agent-doc's FFI plugin backend — centralizing editor plugin logic in Rust rather than duplicating across JetBrains, VS Code, Vim, and Zed.
Ep1: The CRDT Ordering Bug — Skill to Binary Series
CRDT merge preserves data but not semantic ordering. Debugging how user prompts end up below agent responses, discovering IPC caching as the root cause, and a philosophical detour about 'vibe coder' labels.
Lazily: Reactive Primitives Done Right — Context, Slots, Cells, and Signals
Introducing lazily — a multi-language reactive primitives library (Rust, Zig, Python) built on lazy invalidation. Deep dive into Context, Slot, Cell, and Signal abstractions, lazy vs eager reactivity, and how proper hydration (code and body) eliminates waste.
Ep3: AST Parsing & GPU Transcription — Skill to Binary Series
Replacing regex with pulldown-cmark AST, debugging boundary markers across IPC paths, adding CUDA GPU transcription to corky, and designing the YouTube publishing pipeline.
Introducing agent-doc: Documents as the UI for AI Agents
agent-doc turns markdown files into persistent, editable, version-controlled conversations with AI agents. No more ephemeral chat — your documents are the UI.
Ep4: IPC Timeout Deep Dive — Skill to Binary Series
Why does the boundary reposition time out? Debugging the IPC layer between agent-doc and the JetBrains plugin, CRDT vs semantic ordering, and the argument for file descriptors over polling.