I have shipped five small tools this year instead of one big product, Git Dojo, OhNine, Statusline Builder, Claude Blueprint, and RAXXO Studio Each tool solves exactly one problem and stops there, no feature creep, no internal roadmap fights Shipping small forces me to finish things, a habit a single sprawling product lets me avoid indefinitely The pattern only holds because every tool has to earn its own attention, nothing rides on the others The Big Product I Never Shipped For a long stretch, I was building one big thing. Not a specific product I can point to and describe, more a habit of scope. Every idea got folded into the same growing plan, another tab, another settings panel, another "while I'm in there" addition. It felt productive because I was always working on something. It was not productive, because nothing ever crossed the finish line. A plan that keeps absorbing new ideas is not a plan, it is a place where finished work goes to become unfinished work again. The turn came when I noticed how differently I treated small, contained pieces of work. When I sat down to fix one specific annoyance, something with a clear edge around it, I finished. When I sat down to "work on the platform," I drifted. The difference was not effort or time, it was shape. A bounded problem has a visible end. An unbounded one does not, so there is always a reason to keep going instead of stopping and calling it done. That observation is the entire reason Git Dojo, OhNine, Statusline Builder, Claude Blueprint, and RAXXO Studio exist as five separate things instead of five tabs inside one dashboard. Each one started as an itch I could describe in a single sentence. OhNine started as "I want a warning before I hit my Claude limit, not after." Statusline Builder started as "configuring a statusline should not require editing JSON by hand." Git Dojo started as "I want to practice real git commands somewhere the mistakes cost nothing." None of those sentences needed a second paragraph

We just closed the finalization record for Directions 1 through 3 in our knowledge and memory management subsystem. This covers the core pipeline: ingestion, storage, retrieval, and context integration. Here’s what that actually means for the architecture, why we made specific tradeoffs, and how to use it in your own stack. The project has been iterating on how to decouple knowledge persistence from runtime memory while maintaining a unified query interface. Directions 1-3 form the foundation: a document store, a vector index, and a structured memory buffer that combines both. No more ad hoc caching or reinventing the retrieval loop. Everything lives behind a single KnowledgeGraph interface. Direction 1: Raw Document Ingestion and Storage We settled on a partitioned document store backed by a local SQLite database with a blob column for serialized content. Each document entry stores a UUID, source URI, raw text or bytes, a content hash, and a timestamp. The ingestion pipeline deduplicates by hash and runs through an optional extractor chain (e.g., PDF parser, markdown splitter, code chunker). The design decision is to separate storage from indexing entirely. The store is dumb—it only handles CRUD and metadata queries. This keeps the ingestion path simple and testable. Direction 2: Vector Index with Filtered Search Instead of building our own vector database, we wrapped existing infrastructure—Pinecone and a local FAISS fallback—behind an abstraction layer. The finalization record specifies a mandatory metadata filter set that must be packed into every upsert and query call. Each vector embedding carries a document UUID, chunk index, and a free-form tags map. This enables queries like “retrieve all chunks where module == 'networking' and version >= '2.0' ” without scanning unrelated vectors. The finalization also enforces a max-k retrieval of 50 with a similarity threshold of 0.65. Below that, the system returns an empty set rather than noisy garbage. We decided to p

Anthropic shipped Claude Opus 5 on July 24, calling it a step-change over Opus 4.8, not a routine bump The model runs a 1M token context window as both default and maximum, 128k max output tokens, with thinking on by default Anthropic says it approaches Fable 5 intelligence at roughly half the price, with per-token pricing unchanged from Opus 4.8 It shipped everywhere at once, the Claude API, AWS, Google Cloud, and Microsoft Foundry, and is now the default Opus model in Claude Code What Anthropic Actually Shipped On July 24, Anthropic released Claude Opus 5, and the framing in its own documentation is unusually direct about what kind of release this is. Anthropic calls it a step-change improvement over Claude Opus 4.8, not an incremental one, and says the largest gains land in deep reasoning, agentic coding and long-horizon tasks, and test-time compute scaling. That is a specific claim, not marketing language, and it matches how the model is positioned everywhere else in the announcement: as a model built to stay on task across long tool-use loops rather than one built to win a single benchmark screenshot. The capability list is long and mostly practical. Anthropic highlights better code review and bug-finding, with a high hit rate on real bugs and few false positives, holding up even at lower effort levels. It highlights vision improvements, reading charts, documents, and diagrams, and replicating UI and frontend visuals when the model has tools to crop and check its own work. It highlights office and document tasks, generating multi-sheet spreadsheets with real formulas and structured slide decks, and multi-agent coordination, running teams of subagents with writer-verifier patterns and fewer cases of agents stepping on each other's output. What stands out is that this is not a model pitched as a smarter chat assistant. Every capability on the list points at the same audience: people running Claude inside an agent loop, a coding session, or a multi-step workflow,

The Loneliness Protocol of a Solo Tech Founder Loneliness in entrepreneurship is as predictable as a server crash during peak traffic. For a solo founder, it’s a relentless companion, one that doesn't care if you’re in bustling Davao or isolated at your desk. Here’s the brutal truth: isolation can break you if you let it. You’re not just navigating tech challenges, but also the uncharted waters of solo existence, where human connection feels like a distant luxury. The Core Problem & Why This Matters Let me be clear, as a solo tech founder, loneliness isn’t a sidebar issue—it’s central to your survival. You might be a genius with API integrations or a master of patent applications , but if you’re fighting the darkness of isolation, your innovations suffer. The mental load of building something from scratch is immense. Add to that the silence of not having a co-founder or team to bounce ideas off, and you’re skating on thin ice. Why does this matter? Confidence wanes, decision-making suffers, and burnout creeps in. When productivity is tied to connection, and all your colleagues are digital avatars miles away, your business can quickly spiral downwards. This isn’t just about feeling good. It’s about maintaining a sustainable creative energy . If your innovation pipeline clogs with self-doubt, you lose ground, fast. The Systems Engineering Approach The solution isn't a one-size-fits-all. It starts with engineering systems designed to bring people into your virtual workspace. Think beyond the Zoom calls. We’re talking curated, meaningful interactions. Start with regular, structured virtual check-ins with other industry experts. Set these in stone, like a production deployment—a fixed calendar, strict agenda. Engage in remote communities with shared goals. Platforms like Slack and Discord have niche channels dedicated to tech founders. These aren’t just chat rooms; they’re virtual war rooms for brainstorming, networking, and problem-solving. The key here is participation

Four ways to orchestrate business logic in Ruby. One map to find yours. You're building something that involves multiple steps. Charge a card, send an email, update inventory. Simple. Then someone says "What if step 3 fails? What undoes steps 1 and 2?" and suddenly you're evaluating workflow libraries. There are four mainstream approaches in Ruby today — Ruby Reactor , dry-transaction , Trailblazer , and raw Sidekiq jobs. This guide helps you pick the right one — not by ranking them, but by mapping them to the problem you're actually solving. The 30-Second Decision Matrix If you only have 30 seconds, start here: You want... Pick... A simple pipeline — 3-5 steps, top-to-bottom, no parallelism dry-transaction Railway-oriented programming with success/failure tracks, already in the Trailblazer ecosystem Trailblazer A full saga orchestrator — DAG dependency resolution, Sidekiq async, auto-compensation, locks, dashboard Ruby Reactor One-off fire-and-forget jobs, no coordination needed Raw Sidekiq None of these are "better" than the others. They solve different problems. Let's walk through each one. Meet the Libraries dry-transaction (v0.16.0) dry-transaction is a thin, focused gem from the dry-rb ecosystem. It wraps a series of operations in a sequential pipeline with a clean step DSL: class CreateUser < Dry :: Transaction step :validate step :persist step :send_welcome_email def validate ( input ) = # ... def persist ( input ) = # ... def send_welcome_email ( input ) = # ... end Steps run top-to-bottom. If any step returns a Failure , the pipeline stops immediately — no further steps execute. It's a railway under the hood: each step can produce Success(value) or Failure(error) , and the pipeline routes accordingly. What it's great at: Simple, synchronous pipelines. It's the Ruby equivalent of an Either monad chained with bind — clean, predictable, and minimal. If you're already in the dry-rb ecosystem (dry-validation, dry-types, dry-monads), it fits naturally. What it d

Your Claude Code setup doesn't break in one dramatic moment — it degrades a few bytes at a time, and by the time you notice, you've been paying a context tax for weeks. In a previous post I covered running an unattended daily health check with launchd. This one is the follow-up: a three-layer loop that detects that quiet degradation weekly and hands the repair job to claude -p itself. The problem: environments rot quietly if you leave them alone Some things in a Claude Code environment grow just from doing your normal work. ~/.claude/rules/ and MEMORY.md keep getting appended to, until context injection quietly crosses 40KB Experimental agent definition .md files never get archived, leaving dozens to nearly a hundred files under ~/.claude/agents/ permanently loaded Stop hooks fire over and over, creating a hook spam condition Frustration-signaling words pile up in conversation logs and nobody notices A performance audit on 2026-07-11 revealed that "agents I thought I'd archived were still being injected — 99 of them," and that turned out to be the main cause of the degraded experience. That led to the question "so do I have to go check this every week myself?" — and the answer was to automate it , which is what cc-self-audit.sh does. Five degradation metrics and their thresholds The script measures five metrics and flags "red" when any of them crosses its threshold. # 閾値（env変数で上書き可） TH_INJECT_BYTES = " ${ SELF_AUDIT_TH_INJECT :- 40000 } " # rules+CLAUDE.md+MEMORY.md 合計バイト TH_AGENTS = " ${ SELF_AUDIT_TH_AGENTS :- 60 } " # ~/.claude/agents 配下 .md 総数（再帰） TH_STOPSPAM = " ${ SELF_AUDIT_TH_STOPSPAM :- 15 } " # 監査hook発火/週 TH_FRUSTRATION = " ${ SELF_AUDIT_TH_FRUST :- 8 } " # 不満ワード/週 TH_TOOLERR = " ${ SELF_AUDIT_TH_TOOLERR :- 400 } " # tool失敗/週 The first three are static metrics (state at this exact moment); the last two are dynamic metrics (trends since the previous run). That distinction maps directly onto how each one is measured, as described below. Overall design: a thr

Originally published on hexisteme notes . I was about to harden a new agent whose whole job is to turn "should I adopt this library, model, or tool" into a deterministic, auditable verdict instead of a vibe — gates, grades, falsifiers, a learning ledger. Before trusting it with that job, I wanted a design review nobody could dodge. My default pattern was "ask my main coding assistant to look it over," which has the same structural problem as a same-family writer reviewing its own writing: builder and checker share the same blind spots. So this time three roles — Questioner, Answerer, and adversarial Verifier — rotated through three reviewer groups in every possible assignment, across six rounds. Three roles into three groups is exactly six permutations, and I used all of them, so no group ever sat as the permanent judge. The setup: eight targets, six dimensions, three groups The system under review had eight discrete pieces worth judging, pulled from its own codebase rather than picked after the fact: identity and boundaries (what separates a verdict-making agent from a plain fact-gathering one), four type-level invariants blocking an unverified claim from being laundered into a confirmed fact, five deterministic scoring gates that only score fact-labeled evidence, the grade decision and hard-gate demotion logic built on those gates, automatic derivation of the conditions that would prove a verdict wrong, a provenance parser with a host whitelist for fact-grade sources, a learning ledger checking whether its own confidence is honestly calibrated, and the CLI/bus/config surface a human touches. Each got judged on six dimensions: interesting to judge, useful downstream, complete against its own spec, coherent with its docs and siblings, reliable — reproducible, tested, falsifiable — and actually serving the system's purpose. Going in: eight open verdicts on record, zero recorded outcomes, 677 lines of tests. Zero outcomes matters more than it sounds — a learning ledge

Scrum was introduced in the 1990s and became a sensation in the early 2000s. Back then it was marketed as the cure for everything that was wrong with waterfall: slow delivery, rigid plans, unhappy developers. Companies embraced it, created new roles like Scrum Master and Product Owner, and treated it as if it were the universal recipe for agility. Twenty years later, the verdict is clear: the promises didn’t hold up. Scrum didn’t make teams faster or more adaptive. In many places it became the opposite. Scrum assumes that a sprint backlog should remain fixed. That might sound logical in theory, but in reality requirements shift every few days. What seemed like the top priority at the start of the week can already be irrelevant by the end of it. The result is wasted work and frustrated developers. It also lives in an awkward middle ground. It’s not fully planned like waterfall, but it’s not truly flexible like kanban either. You don’t get the clarity of one or the flow of the other. Teams are left with the worst of both worlds. The ceremonies were meant to improve communication, but they quickly turn into a drag. Daily stand-ups, planning, retrospectives… they eat time without producing much value. Too often they become status update theater. And the roles that were supposed to help—Scrum Masters, Product Owners—end up adding bureaucracy instead of removing it. Retrospectives are a perfect example. They’re supposed to drive continuous improvement, but in practice they repeat the same obvious points, produce action items no one follows up on, and force people into artificial formats that feel childish. Problems that could be solved on the spot are postponed for the sake of “the process.” Another hidden cost is how Scrum erodes expertise. The culture of “everyone has a voice” sounds inclusive, but it often means specialists get drowned out. After explaining the same things over and over, they get tired and stop fighting. Wrong ideas end up implemented just because they