<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Mayur Parve on Medium]]></title>
        <description><![CDATA[Stories by Mayur Parve on Medium]]></description>
        <link>https://medium.com/@parvemayur?source=rss-6cd41a5da5ef------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*iHG-d1yxkXWP4Regb1qv3A.jpeg</url>
            <title>Stories by Mayur Parve on Medium</title>
            <link>https://medium.com/@parvemayur?source=rss-6cd41a5da5ef------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:15:56 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@parvemayur/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[What Is an “Agent Harness”]]></title>
            <link>https://medium.com/@parvemayur/what-is-an-agent-harness-c889f42222c6?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/c889f42222c6</guid>
            <category><![CDATA[agent-harness]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 08:44:48 GMT</pubDate>
            <atom:updated>2026-07-20T08:44:48.112Z</atom:updated>
            <content:encoded><![CDATA[<p>If you’ve spent any time around AI tools lately, you’ve probably heard people throw around the term “agent harness.” It sounds technical and a little intimidating, but the idea behind it is actually pretty simple once someone breaks it down without the jargon.</p><p>Here’s the short version: the AI model is the brain. The harness is everything around the brain that lets it actually do things in the real world.</p><h3>Think of it like a car</h3><p>An AI model, on its own, is just really good at predicting the next word in a sentence. That’s it. It doesn’t know how to open a file, click a button, browse the internet, or run code. Left alone, it can only talk.</p><p>The harness is what gives it hands.</p><p>A good comparison is a car engine versus the actual car. The engine is powerful, but it can’t drive anywhere by itself. It needs a steering wheel, brakes, a fuel line, sensors, and a body around it before it becomes something you can actually use to get somewhere. The harness is all of that surrounding machinery. The model is just the engine.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/875/0*BimvLeeqC75bI_06" /></figure><h3>What a harness actually does</h3><p>Strip it down, and a harness is usually doing a handful of jobs:</p><p><strong>Giving the model tools.</strong> This is what lets an AI agent open a file, search the web, or run a piece of code. The model itself can’t do any of that — it can only ask for it. The harness is the part that actually carries out the request and reports back what happened.</p><p><strong>Remembering things.</strong> A conversation can get long, and the model can’t hold onto everything forever. The harness decides what’s worth keeping around and what can be dropped, kind of like a personal assistant deciding what’s worth writing down versus what to let go.</p><p><strong>Checking before doing something risky.</strong> Should the AI ask you before deleting a file or sending an email? That’s not something the model decides on its own — the harness is the layer that adds those safety checks.</p><p><strong>Handling mistakes.</strong> Things go wrong. A tool call fails, a website doesn’t load, a command errors out. A good harness notices this and tries again sensibly. A bad one just gets confused and keeps repeating the same mistake.</p><p><strong>Planning the steps.</strong> For anything that takes more than one action, something needs to figure out the order of steps and whether the plan needs to change halfway through. That’s the harness’s job too.</p><h3>Why this actually matters</h3><p>Here’s the part that trips people up: when an AI agent feels slow, confused, or unreliable, people usually blame the model. “This AI just isn’t smart enough.”</p><p>But a lot of the time, the model is fine. The problem is the harness around it — bad memory handling, no proper error recovery, clunky tool access. Two different products can use the exact same underlying AI model and feel completely different to use, purely because of how well (or badly) the harness was built.</p><p>It’s a bit like two chefs using the same knife. One produces a great meal, the other cuts themselves. The knife isn’t the deciding factor. The skill of the hand holding it is.</p><h3>The simple takeaway</h3><p>Next time you hear someone praise or criticize an “AI agent,” it’s worth asking: are they really talking about the model, or are they talking about everything built around it? More often than not, it’s the harness doing the heavy lifting — quietly, in the background, without ever getting the credit.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c889f42222c6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Loop Engineering: Why You Should Stop Prompting Your Coding Agent]]></title>
            <link>https://medium.com/@parvemayur/loop-engineering-why-you-should-stop-prompting-your-coding-agent-11adad91a341?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/11adad91a341</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[loop-engineering]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Fri, 03 Jul 2026 11:16:36 GMT</pubDate>
            <atom:updated>2026-07-03T11:18:48.213Z</atom:updated>
            <content:encoded><![CDATA[<h4><strong>The job isn’t writing better prompts anymore. It’s designing the thing that writes them for you.</strong></h4><p>A few weeks ago I caught myself doing something I used to be proud of: sitting with a coding agent for two straight hours, feeding it one instruction at a time, reading what came back, correcting it, feeding it the next thing. I used to call that “being good at prompting.” Watching myself do it this time, it looked more like babysitting.</p><p>Around the same time I ran into an idea that stuck with me — that you shouldn’t be prompting coding agents anymore, you should be designing loops that prompt them for you. A few people building seriously with these tools have started describing their actual job the same way: writing loops, not writing prompts. I went digging into what that meant in practice, and it named something I’d been circling without the vocabulary for it.</p><p>The name is loop engineering. And once I understood what it actually meant, I felt a little dumb for how long I’d been doing the manual version.</p><h3>What “the loop” actually is</h3><p>Here’s the shift in plain terms. For the last couple of years, using a coding agent meant you were the loop. You typed something, you read the response, you typed the next thing, forever, one turn at a time, with your own attention as the glue holding every step together.</p><p>Loop engineering is building a small system that does that holding for you. Something that finds the work on its own, hands it to an agent, checks what came back, records what’s done, and decides what happens next — without you sitting there clicking through each turn.</p><p>That’s it. That’s the whole reframe. You stop being the one who prompts. You become the one who designed the thing that prompts.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Zy4sqP3Q9knpghJGXqfH6A.png" /></figure><h3>The five pieces that make a loop actually work</h3><p>Reading through how this gets built in practice — across the current wave of agentic coding tools — the same five ingredients keep showing up, plus one that ties them together.</p><p><strong>Something that runs on its own schedule.</strong> A task that fires every morning, checks yesterday’s CI failures or open issues, and only bothers you when it actually finds something worth looking at. The runs that turn up nothing just quietly archive themselves.</p><p><strong>Isolated workspaces for parallel work.</strong> The moment you have more than one agent touching a codebase, they start stepping on each other’s files. Giving each one its own checkout — a separate branch sharing the same history — means two agents working at once don’t collide the way two engineers editing the same lines without talking would.</p><p><strong>Written-down project knowledge.</strong> Instead of re-explaining your conventions, your build quirks, and the “we don’t do it that way because of that one incident” context every single session, you write it once, somewhere the agent reads automatically. Skip this and the loop re-derives your entire project from zero every cycle. Include it and the thing actually compounds over time instead of starting cold each morning.</p><p><strong>A way to reach your real tools.</strong> A loop that can only see the filesystem is a small, mostly useless loop. Connecting it to your issue tracker, your staging environment, your team chat is the difference between an agent that tells you what it would fix and a loop that opens the pull request, links the ticket, and pings the channel once the tests are green.</p><p><strong>A second agent whose only job is checking the first one’s work.</strong> This might be the single most important piece, and it’s the one most people skip when they’re starting out. The model that wrote the code is a terrible judge of whether the code is actually right — it’s grading its own homework. A separate agent, sometimes running a different model entirely, catching what the first one talked itself into, is what makes it safe to walk away while the loop runs.</p><p>And underneath all five: a place to remember what’s been tried. A markdown file, a project board, anything that lives outside a single conversation. The model forgets everything the moment the session ends. The file on disk doesn’t.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gZ1dt9SGjsc9kZ65jywgMw.png" /></figure><h3>What one of these actually looks like running</h3><p>Put the pieces together and a single automated thread starts to resemble a small control panel rather than a chat window.</p><p>A scheduled run kicks off every morning against a repo. It reads the previous day’s failures and open issues and writes its findings somewhere durable. For anything worth fixing, it opens an isolated workspace and sends one agent to draft a fix, then a second agent to check that draft against the project’s actual conventions and tests. If the fix holds up, the loop opens the pull request and updates the ticket on its own. Anything it can’t resolve gets flagged for a person. And the next morning’s run picks up exactly where the last one left off, because the state file remembers.</p><p>You didn’t prompt a single one of those steps. You designed the system once, and the system does the prompting from here.</p><h3>Where this stops being a shortcut</h3><p>Here’s the part I think is easy to skip past when something this useful shows up: the loop doesn’t remove you from the work, it just moves where your attention has to go.</p><p>Verification is still entirely on you. A loop running while you’re not watching is also a loop making mistakes while you’re not watching, and the second agent checking the first one’s work isn’t proof, it’s just a claim that got double-checked once. Your job is still to actually confirm the thing works before it ships, not to trust that it probably does because a loop said so.</p><p>Your own understanding of the codebase can quietly rot if you let it. The faster a loop ships code you didn’t personally write, the wider the gap grows between what exists in the repo and what you actually understand about it. A smooth, well-built loop doesn’t fix that gap. It just makes it grow faster if you stop reading what comes out the other end.</p><p>And there’s a comfortable posture that’s genuinely dangerous: once the loop runs itself, it’s tempting to stop having an opinion about the output and just take whatever it hands back. Designing the loop well is the opposite of that. It only works if you’re using it to move faster on something you already understand deeply — not as a way to avoid understanding the work at all. Two people can build the exact same loop and walk away with completely different outcomes, because the loop genuinely can’t tell which one you’re doing. You have to be the one who knows.</p><p>That’s what makes this harder than getting good at prompting, not easier. The skill didn’t go away. It moved up a level — from writing the instruction to designing the system that decides what the instruction should be.</p><p>Build the loop. Just don’t stop being the engineer who has to answer for what it built.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=11adad91a341" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PageIndex: The Smarter Alternative to Vector Databases for AI-Powered Search]]></title>
            <link>https://medium.com/@parvemayur/pageindex-the-smarter-alternative-to-vector-databases-for-ai-powered-search-d7644cb18c3b?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/d7644cb18c3b</guid>
            <category><![CDATA[enterprise-ai]]></category>
            <category><![CDATA[rags]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[vector-database]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Tue, 03 Mar 2026 13:46:15 GMT</pubDate>
            <atom:updated>2026-03-03T13:46:15.167Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Why the next generation of semantic search doesn’t need embeddings, ANN indexes, or infrastructure headaches</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/817/1*FkvLd1vZH0o2RjAVCd0yXg.png" /></figure><h3>The Vector Database Promise — and Its Hidden Costs</h3><p>Vector databases took the AI world by storm. The pitch was compelling: convert your documents into high-dimensional embeddings, store them in a specialized database, and retrieve semantically similar content in milliseconds. Pinecone, Weaviate, Qdrant, Chroma — a whole ecosystem bloomed overnight.</p><p>But as teams moved from proof-of-concept to production, the cracks started to show. Vector databases are powerful, yes. But they’re also complex, expensive, and surprisingly brittle when your data changes.</p><p>Enter <strong>PageIndex</strong> — a fundamentally different approach to building intelligent search and retrieval systems that is simpler, faster to deploy, and more accurate for many real-world use cases.</p><h3>What Is PageIndex?</h3><p>PageIndex is a document-first indexing paradigm that organizes information at the page or chunk level using a hierarchical, structured index rather than a flat embedding space. Instead of projecting every document into a vector and hoping nearest-neighbor search finds the right result, PageIndex maintains rich metadata, structural relationships, and semantic annotations in a format that’s both human-readable and machine-queryable.</p><p>Think of it like the index at the back of a textbook — but dynamic, AI-aware, and queryable at the speed of a modern database.</p><h3>The Core Problems with Vector Databases</h3><p>Before we dive into why PageIndex is better, let’s be honest about what makes vector databases hard to work with.</p><p><strong>1. The Embedding Drift Problem</strong></p><p>Your vector database is only as good as your embeddings. When you switch embedding models — say, from OpenAI’s text-embedding-ada-002 to a newer model — your entire index becomes stale. You have to re-embed every document, which for a large corpus can mean significant time, cost, and downtime. PageIndex decouples the index from the embedding model, making model upgrades seamless.</p><p><strong>2. Approximate Nearest Neighbor is Approximate</strong></p><p>ANN algorithms like HNSW and IVF are fast, but they sacrifice recall for speed. In retrieval-augmented generation (RAG) pipelines, missing the right document can cascade into hallucinations or wrong answers. The “approximate” in ANN is not a footnote — it’s a fundamental limitation. PageIndex uses exact, structured lookups that guarantee the right content is retrieved when it exists.</p><p><strong>3. Metadata Filtering is Bolted On</strong></p><p>Filtering in vector databases is a second-class citizen. Want to retrieve documents from a specific author, date range, or department? You need to store metadata separately, apply pre- or post-filters, and hope the intersection of your semantic results and your metadata filter isn’t empty. PageIndex treats metadata as a first-class index dimension, making hybrid queries natural and efficient.</p><p><strong>4. Operational Complexity</strong></p><p>Running a vector database in production means managing a separate service, handling index replication, tuning recall-vs-latency tradeoffs, and paying per-query or per-vector costs. For many teams, this is infrastructure overhead that adds weeks to deployment timelines. PageIndex can run embedded within your existing stack — no new services to operate.</p><p><strong>5. Stale Index Updates</strong></p><p>Most vector databases require a full re-index or at best expensive upsert operations when documents change. PageIndex is designed for incremental updates — change a page, update the index for that page. It’s as simple as updating a database row.</p><h3>How PageIndex Works</h3><p>PageIndex organizes your document corpus into a tree-structured index where each node represents a logical unit — a page, a section, a paragraph — annotated with:</p><ul><li><strong>Semantic tags</strong>: AI-generated topic labels and entity mentions</li><li><strong>Structural metadata</strong>: position in document hierarchy, parent/sibling relationships</li><li><strong>Provenance data</strong>: source document, author, timestamp, access controls</li><li><strong>Relevance signals</strong>: cross-references to related nodes within and across documents</li></ul><p>At query time, PageIndex doesn’t compute vector similarity. Instead, it traverses the index using a combination of keyword matching, semantic tag lookup, and structural traversal — finding not just the closest match, but the <em>right</em> match in context.</p><p>This is a fundamentally different model: <strong>retrieval by structure and meaning, not by geometric proximity in embedding space.</strong></p><h3>Where PageIndex Beats Vector Databases</h3><h3>Enterprise Document Search</h3><p>When users search an internal knowledge base, they’re often looking for a specific policy, procedure, or answer to a structured question. Semantic similarity is helpful, but structural retrieval — “find the section on data retention in our compliance policy” — is often more precise. PageIndex excels here because it understands document structure, not just content.</p><h3>Long-Form Content and Books</h3><p>Vector databases chunk long documents into fixed-size windows and lose structural context in the process. PageIndex preserves the full document hierarchy — chapters, sections, subsections — and can retrieve at any level of granularity while maintaining awareness of surrounding context.</p><h3>Frequently Updated Corpora</h3><p>For wikis, documentation sites, or knowledge bases that change daily, vector databases are a maintenance headache. PageIndex supports surgical updates: change a section, update its index entries. No re-embedding, no index rebuilds, no service disruptions.</p><h3>Regulated and Auditable Environments</h3><p>When you need to know <em>exactly</em> which documents were retrieved and <em>why</em>, vector databases give you cosine similarity scores — not exactly a convincing audit trail. PageIndex retrieval is fully explainable: here is the path through the index, here are the matching tags, here is the structural reason this document was returned.</p><h3>Cost-Sensitive Applications</h3><p>Embedding APIs aren’t free, and neither are vector database hosting costs at scale. PageIndex eliminates the ongoing embedding cost after initial indexing and runs efficiently on standard database infrastructure your team already pays for.</p><h3>When Vector Databases Still Make Sense</h3><p>To be fair, vector databases have genuine strengths. They’re excellent for:</p><ul><li><strong>Image and multimodal search</strong>, where structured metadata is sparse and visual similarity is the primary signal</li><li><strong>Recommendation systems</strong> where collaborative filtering and embedding-based similarity are well-studied and effective</li><li><strong>Large-scale fuzzy matching</strong> across extremely diverse, unstructured content with no schema</li></ul><p>If your use case is pure semantic similarity over unstructured content with no need for structured retrieval, vector databases remain a solid choice. PageIndex is not a silver bullet — it’s the right tool for a broad and important class of retrieval problems that vector databases handle poorly.</p><h3>Getting Started with PageIndex</h3><p>Adopting PageIndex typically involves three steps:</p><p><strong>1. Document Ingestion and Parsing</strong>: Parse your source documents into a hierarchical chunk structure — respecting headers, sections, and logical boundaries rather than arbitrary character limits.</p><p><strong>2. Index Construction</strong>: Build the PageIndex by extracting semantic annotations (using a lightweight LLM or NLP pipeline), recording structural relationships, and storing metadata. This is a one-time operation per document, with incremental updates as documents change.</p><p><strong>3. Query Integration</strong>: Replace your vector similarity search calls with PageIndex queries. Your RAG pipeline retrieves structured, context-aware chunks that your LLM can reason over more reliably.</p><p>Many teams find that switching from a vector database to PageIndex reduces their retrieval latency, improves answer quality in RAG applications, and dramatically simplifies their infrastructure footprint.</p><h3>The Bottom Line</h3><p>Vector databases solved an important problem at a specific moment in the AI development curve. But they were designed for a world where “semantic search” meant “find things that are kind of similar” — and they carry the architectural assumptions and operational costs of that design.</p><p>PageIndex represents a more mature approach: retrieval that respects structure, supports exact and hybrid queries, integrates naturally with your existing data infrastructure, and gets more accurate as your corpus gets more organized.</p><p>For most enterprise knowledge management, documentation search, and RAG applications, PageIndex isn’t just an alternative to vector databases — it’s an upgrade.</p><p><em>Have you made the switch from vector databases to a structured retrieval approach? Share your experience in the comments below.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d7644cb18c3b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Implementing Infinite Scroll with SQL: Why Cursor-Based Pagination Beats OFFSET]]></title>
            <link>https://medium.com/@parvemayur/implementing-infinite-scroll-with-sql-why-cursor-based-pagination-beats-offset-e0222912ca76?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/e0222912ca76</guid>
            <category><![CDATA[database]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[best-practices]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[sql]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Tue, 24 Feb 2026 06:30:23 GMT</pubDate>
            <atom:updated>2026-02-24T06:38:20.775Z</atom:updated>
            <content:encoded><![CDATA[<p>Infinite scroll has become a staple of modern web applications, from social media feeds to e-commerce product listings. While the frontend implementation might seem straightforward, the backend SQL strategy you choose can dramatically impact your application’s performance and user experience. This article explores why traditional OFFSET-based pagination fails at scale and how cursor-based pagination provides a robust alternative.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*37sPPTKLG7ESOyBAW8kfRA.png" /></figure><h3>The Problem with OFFSET</h3><p>When developers first implement pagination, they often reach for the familiar OFFSET and LIMIT pattern:</p><pre>SELECT * FROM posts<br>ORDER BY created_at DESC<br>LIMIT 20 OFFSET 60;</pre><p>This query fetches the fourth page of results (assuming 20 items per page). It looks clean and works perfectly fine for small datasets. However, this approach harbors serious performance issues that become apparent as your data grows.</p><h3>Why OFFSET Fails at Scale</h3><h4>1. The Database Still Scans All Skipped Rows</h4><p>Here’s the crucial misunderstanding: when you use OFFSET 10000, the database doesn&#39;t magically jump to row 10,001. Instead, it:</p><ol><li>Scans and processes the first 10,000 rows</li><li>Discards them entirely</li><li>Finally returns the next 20 rows you actually want</li></ol><p>Imagine reading a 500-page book but being told to throw away the first 499 pages. That’s essentially what OFFSET does. As users scroll deeper into your content, each subsequent page requires more and more wasted work.</p><p>Let’s look at actual performance numbers from a table with 1 million posts:</p><pre>-- Page 1: Fast (0.003 seconds)<br>SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 0;</pre><pre>-- Page 50: Slower (0.045 seconds)<br>SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 1000;</pre><pre>-- Page 500: Painfully slow (0.380 seconds)<br>SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 10000;</pre><pre>-- Page 5000: Unacceptable (3.2 seconds)<br>SELECT * FROM posts ORDER BY created_at DESC LIMIT 20 OFFSET 100000;</pre><p>Notice how query time grows linearly with the offset value. This creates a terrible user experience where scrolling gets progressively slower.</p><h4>2. Inconsistent Results When Data Changes</h4><p>OFFSET-based pagination suffers from what I call “the shifting data problem.” Consider this scenario:</p><ol><li>User loads page 1 (items 1–20)</li><li>User scrolls to page 2, requesting items 21–40</li><li>BUT: 5 new posts were created between these requests</li><li>Now items that were 21–40 have shifted to positions 26–45</li><li>The user sees 5 duplicate items and misses 5 items entirely</li></ol><p>This isn’t a theoretical edge case. On high-traffic platforms like Twitter or Reddit, new content arrives constantly. Users might see the same post twice or miss posts entirely, creating confusion and frustration.</p><h4>3. Difficulty Handling Deletions</h4><p>Similarly, when items are deleted between page loads:</p><ol><li>User sees items 1–20 on page 1</li><li>Three items (positions 18, 19, 20) get deleted</li><li>User requests page 2 (OFFSET 20)</li><li>They now skip items that should have been visible</li></ol><p>This creates gaps in the user’s feed that they’ll never discover.</p><h3>The Solution: Cursor-Based Pagination</h3><p>Cursor-based pagination (also called keyset pagination) solves these problems by using the data itself as a bookmark rather than counting rows.</p><h3>How It Works</h3><p>Instead of saying “give me 20 items starting at position 100,” you say “give me 20 items after this specific item.”</p><pre>-- Initial request (first page)<br>SELECT * FROM posts<br>ORDER BY created_at DESC, id DESC<br>LIMIT 20;</pre><pre>-- Subsequent request (next page)<br>-- Using the last item&#39;s created_at and id as the cursor<br>SELECT * FROM posts<br>WHERE (created_at, id) &lt; (&#39;2024-02-15 10:30:00&#39;, 12345)<br>ORDER BY created_at DESC, id DESC<br>LIMIT 20;</pre><p>The key insight: we’re using the actual values from the last row as a reference point, not an arbitrary offset number.</p><h3>Why This Works Better</h3><h4>1. Consistent Performance</h4><p>No matter how deep users scroll, the database uses an index to jump directly to the cursor position. The query always scans roughly the same number of rows (20), whether you’re on page 1 or page 1000.</p><p>Performance comparison on the same 1 million row table:</p><pre>-- Cursor-based: Always fast (0.003-0.005 seconds)<br>SELECT * FROM posts<br>WHERE (created_at, id) &lt; (cursor_timestamp, cursor_id)<br>ORDER BY created_at DESC, id DESC<br>LIMIT 20;</pre><p>The performance remains constant regardless of scroll depth.</p><h4>2. No Duplicates or Gaps</h4><p>Because we’re using absolute positions in the data rather than relative positions, new insertions don’t cause issues:</p><ol><li>User sees items up to post_id 1000</li><li>New posts 1001–1010 are created</li><li>User requests next page with cursor = 1000</li><li>Query returns items &lt; 1000, skipping the new posts entirely</li><li>User sees a consistent, gap-free feed</li></ol><p>New content doesn’t interfere with pagination in progress.</p><h4>3. Stateless and Cacheable</h4><p>Each cursor is completely self-contained. You can:</p><ul><li>Share URLs with cursors to specific positions</li><li>Cache results at the edge</li><li>Distribute requests across read replicas</li><li>Resume pagination after server restarts</li></ul><h3>Implementing Cursor-Based Pagination</h3><h3>Basic Implementation</h3><p>Let’s build a complete example for a social media posts feed:</p><pre>-- Table structure<br>CREATE TABLE posts (<br>    id BIGINT PRIMARY KEY AUTO_INCREMENT,<br>    user_id BIGINT NOT NULL,<br>    content TEXT,<br>    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,<br>    INDEX idx_created_id (created_at DESC, id DESC)<br>);</pre><p>Note the composite index on (created_at, id). This is crucial for performance.</p><pre>-- First page request<br>SELECT id, user_id, content, created_at<br>FROM posts<br>ORDER BY created_at DESC, id DESC<br>LIMIT 21;  -- Fetch one extra to determine if there&#39;s a next page</pre><p>Why fetch 21 items when we only show 20? The extra item tells us whether there’s more data without requiring a separate COUNT query.</p><pre>-- Subsequent pages<br>-- Client sends the last item&#39;s created_at and id as cursor<br>SELECT id, user_id, content, created_at<br>FROM posts<br>WHERE (created_at, id) &lt; (&#39;2024-02-15 10:30:00&#39;, 12345)<br>ORDER BY created_at DESC, id DESC<br>LIMIT 21;</pre><h3>Backend Code Example (Node.js/Express)</h3><pre>app.get(&#39;/api/posts&#39;, async (req, res) =&gt; {<br>    const limit = 20;<br>    const cursor = req.query.cursor; // Format: &quot;timestamp_id&quot;<br>    <br>    let query = `<br>        SELECT id, user_id, content, created_at<br>        FROM posts<br>    `;<br>    <br>    let params = [];<br>    <br>    if (cursor) {<br>        // Decode cursor<br>        const [timestamp, id] = cursor.split(&#39;_&#39;);<br>        query += ` WHERE (created_at, id) &lt; (?, ?)`;<br>        params = [timestamp, id];<br>    }<br>    <br>    query += ` ORDER BY created_at DESC, id DESC LIMIT ?`;<br>    params.push(limit + 1);<br>    <br>    const posts = await db.query(query, params);<br>    <br>    // Check if there are more results<br>    const hasMore = posts.length &gt; limit;<br>    if (hasMore) posts.pop(); // Remove the extra item<br>    <br>    // Generate cursor for next page<br>    let nextCursor = null;<br>    if (hasMore &amp;&amp; posts.length &gt; 0) {<br>        const lastPost = posts[posts.length - 1];<br>        nextCursor = `${lastPost.created_at}_${lastPost.id}`;<br>    }<br>    <br>    res.json({<br>        data: posts,<br>        nextCursor: nextCursor,<br>        hasMore: hasMore<br>    });<br>});</pre><h3>Frontend Example (React)</h3><pre>import { useState, useEffect } from &#39;react&#39;;</pre><pre>function InfiniteScrollFeed() {<br>    const [posts, setPosts] = useState([]);<br>    const [cursor, setCursor] = useState(null);<br>    const [loading, setLoading] = useState(false);<br>    const [hasMore, setHasMore] = useState(true);<br>    <br>    const loadMore = async () =&gt; {<br>        if (loading || !hasMore) return;<br>        <br>        setLoading(true);<br>        const url = cursor <br>            ? `/api/posts?cursor=${cursor}`<br>            : &#39;/api/posts&#39;;<br>            <br>        const response = await fetch(url);<br>        const data = await response.json();<br>        <br>        setPosts(prev =&gt; [...prev, ...data.data]);<br>        setCursor(data.nextCursor);<br>        setHasMore(data.hasMore);<br>        setLoading(false);<br>    };<br>    <br>    useEffect(() =&gt; {<br>        loadMore();<br>    }, []);<br>    <br>    // Infinite scroll detection<br>    useEffect(() =&gt; {<br>        const handleScroll = () =&gt; {<br>            if (window.innerHeight + window.scrollY &gt;= <br>                document.body.offsetHeight - 500) {<br>                loadMore();<br>            }<br>        };<br>        <br>        window.addEventListener(&#39;scroll&#39;, handleScroll);<br>        return () =&gt; window.removeEventListener(&#39;scroll&#39;, handleScroll);<br>    }, [cursor, loading, hasMore]);<br>    <br>    return (<br>        &lt;div&gt;<br>            {posts.map(post =&gt; (<br>                &lt;PostCard key={post.id} post={post} /&gt;<br>            ))}<br>            {loading &amp;&amp; &lt;LoadingSpinner /&gt;}<br>        &lt;/div&gt;<br>    );<br>}</pre><h3>Advanced Patterns</h3><h3>Multi-Column Sorting</h3><p>What if you need to sort by multiple criteria, like score and then date?</p><pre>-- Sort by score (descending), then created_at (descending), then id<br>SELECT id, title, score, created_at<br>FROM posts<br>WHERE (score, created_at, id) &lt; (85, &#39;2024-02-15 10:30:00&#39;, 12345)<br>ORDER BY score DESC, created_at DESC, id DESC<br>LIMIT 21;</pre><p>The tuple comparison (score, created_at, id) &lt; (...) works lexicographically, comparing left to right.</p><p>Important: Your index must match the sort order exactly:</p><pre>CREATE INDEX idx_score_created_id ON posts(score DESC, created_at DESC, id DESC);</pre><h3>Handling NULL Values</h3><p>NULL values can cause unexpected behavior in cursor comparisons. If your sort column allows NULLs, handle them explicitly:</p><pre>-- For columns that might be NULL<br>SELECT id, title, score, created_at<br>FROM posts<br>WHERE (<br>    (score IS NOT NULL AND (score, created_at, id) &lt; (?, ?, ?))<br>    OR (score IS NULL AND ? IS NOT NULL)<br>    OR (score IS NULL AND ? IS NULL AND (created_at, id) &lt; (?, ?))<br>)<br>ORDER BY score DESC NULLS LAST, created_at DESC, id DESC<br>LIMIT 21;</pre><p>Or better yet, use a default value instead of NULL to simplify queries:</p><pre>ALTER TABLE posts MODIFY score INT DEFAULT 0;</pre><h3>Bidirectional Pagination</h3><p>For interfaces that allow both forward and backward navigation:</p><pre>-- Forward (next page)<br>SELECT * FROM posts<br>WHERE (created_at, id) &lt; (cursor_ts, cursor_id)<br>ORDER BY created_at DESC, id DESC<br>LIMIT 21;</pre><pre>-- Backward (previous page)<br>SELECT * FROM (<br>    SELECT * FROM posts<br>    WHERE (created_at, id) &gt; (cursor_ts, cursor_id)<br>    ORDER BY created_at ASC, id ASC<br>    LIMIT 21<br>) AS reversed<br>ORDER BY created_at DESC, id DESC;</pre><p>The backward query reverses the comparison and sort order, then re-reverses the results to maintain consistent ordering.</p><h3>When OFFSET Might Be Acceptable</h3><p>Despite its drawbacks, OFFSET-based pagination has legitimate use cases:</p><h3>1. Traditional Page Numbers</h3><p>If users need to jump to arbitrary page numbers (like search results with “Page 1, 2, 3…” navigation), OFFSET is unavoidable. However, limit the maximum page depth:</p><pre>const MAX_PAGE = 100;<br>const page = Math.min(req.query.page || 1, MAX_PAGE);</pre><h3>2. Small, Static Datasets</h3><p>For administrative interfaces with hundreds (not millions) of rows that change infrequently, OFFSET works fine and is simpler to implement.</p><h3>3. Reporting and Analytics</h3><p>When generating reports where users need to see exact row counts and jump to specific pages, OFFSET makes sense. Users expect to wait longer for these operations.</p><h3>Performance Best Practices</h3><h3>1. Index Everything in Your ORDER BY Clause</h3><p>This cannot be overstated. If you sort by (created_at DESC, id DESC), you need an index on exactly those columns in exactly that order:</p><pre>CREATE INDEX idx_created_id ON posts(created_at DESC, id DESC);</pre><p>Verify your index is being used:</p><pre>EXPLAIN SELECT * FROM posts<br>WHERE (created_at, id) &lt; (&#39;2024-02-15 10:30:00&#39;, 12345)<br>ORDER BY created_at DESC, id DESC<br>LIMIT 20;</pre><p>Look for “Using index” in the Extra column.</p><h3>2. Always Include a Unique Column</h3><p>Your cursor must include a unique, sequential column (usually the primary key) as a tiebreaker. Otherwise, rows with identical sort values will cause inconsistencies:</p><pre>-- Bad: Multiple posts can have same created_at<br>WHERE created_at &lt; &#39;2024-02-15 10:30:00&#39;</pre><pre>-- Good: Add id as tiebreaker<br>WHERE (created_at, id) &lt; (&#39;2024-02-15 10:30:00&#39;, 12345)</pre><h3>3. Use Covering Indexes</h3><p>If possible, include all selected columns in your index to avoid table lookups:</p><pre>CREATE INDEX idx_posts_covering ON posts(<br>    created_at DESC, <br>    id DESC, <br>    user_id, <br>    content(100)  -- Prefix index for text columns<br>);</pre><p>This allows the database to satisfy the query entirely from the index.</p><h3>4. Monitor Query Performance</h3><p>Set up slow query logging and alerts:</p><pre>-- MySQL<br>SET GLOBAL slow_query_log = &#39;ON&#39;;<br>SET GLOBAL long_query_time = 0.5;  -- Log queries over 500ms</pre><p>Regularly review slow queries and optimize accordingly.</p><h3>Conclusion</h3><p>While OFFSET-based pagination seems simple and intuitive, it creates performance problems that worsen as your application grows. Cursor-based pagination requires slightly more upfront work but provides consistent performance, accurate results, and better user experience at any scale.</p><p>The key takeaways:</p><ul><li>OFFSET scans and discards all skipped rows, causing linear performance degradation</li><li>Cursor-based pagination uses indexes to jump directly to the desired position</li><li>Always include a unique column (like ID) in your cursor to ensure consistency</li><li>Create appropriate composite indexes matching your sort criteria</li><li>Encode cursors to prevent manipulation and improve security</li></ul><p>For infinite scroll implementations, cursor-based pagination isn’t just a best practice — it’s the only scalable solution that maintains performance and accuracy as your data grows.</p><p>Start building with cursors today, and your future self (and your users) will thank you when your application scales to millions of rows.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e0222912ca76" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everything Claude Code: The Battle-Tested Configuration That Won an Anthropic Hackathon]]></title>
            <link>https://medium.com/@parvemayur/everything-claude-code-the-battle-tested-configuration-that-won-an-anthropic-hackathon-55484957f76b?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/55484957f76b</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 05:06:53 GMT</pubDate>
            <atom:updated>2026-02-13T05:06:53.507Z</atom:updated>
            <content:encoded><![CDATA[<p>Most developers using Claude Code are working with the defaults.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/900/0*Br_5DAK4q5maNHak" /></figure><p>They ask Claude to write some code. Sometimes it works. Sometimes it doesn’t. When it breaks, they manually debug. When context gets messy, they start a new session and lose everything. Their workflow is essentially: hope for the best, clean up the mess later.</p><p>But some developers have gone deeper.</p><p>One team won the Anthropic x Forum Ventures hackathon building a production application entirely using Claude Code. Not as a gimmick. Not as a demo. As their actual development workflow for shipping real features.</p><p>Their secret? A comprehensive configuration system evolved over 10+ months of intensive daily use. And they open-sourced the whole thing.</p><h3>What Is Everything Claude Code?</h3><p><a href="https://github.com/affaan-m/everything-claude-code">Everything Claude Code</a> is a complete collection of Claude Code configurations: agents, skills, hooks, commands, rules, and MCP setups. Think of it as the missing manual for making Claude Code actually productive at scale.</p><p>The repo has accumulated 35,000+ stars because it solves a problem most people don’t realize they have: <strong>Claude Code is powerful out of the box, but it lacks the scaffolding to be consistently reliable.</strong></p><p>Without structure:</p><ul><li>Context windows fill with garbage</li><li>Quality degrades over long sessions</li><li>You repeat the same instructions every conversation</li><li>No systematic verification of what Claude builds</li><li>Knowledge doesn’t persist between sessions</li></ul><p>Everything Claude Code fixes this through deliberate configuration.</p><h3>The Philosophy</h3><p>The entire system is built on a few core principles:</p><h3>1. Claude Should Know What You Expect</h3><p>Instead of explaining “use immutability” every conversation, encode it in rules that always apply:</p><pre># rules/coding-style.md</pre><pre>- Prefer immutability (const over let, readonly over mutable)<br>- No files over 300 lines<br>- Extract complex logic into pure functions<br>- Use functional patterns over imperative</pre><p>Rules live in ~/.claude/rules/ and inject into every Claude Code session automatically.</p><h3>2. Delegation Over Monolithic Sessions</h3><p>Long conversations degrade. The solution isn’t larger context windows — it’s specialized subagents with limited scope.</p><p>Instead of asking Claude to plan AND implement AND review in one session, you spawn focused agents:</p><pre># agents/planner.md<br>Tools: Read, Grep, Glob<br>Model: Opus</pre><pre>You are a senior technical lead planning implementation...</pre><pre># agents/code-reviewer.md  <br>Tools: Read, Grep, Bash<br>Model: Opus</pre><pre>You are a senior code reviewer checking for quality, security...</pre><p>Each agent gets fresh context. Each handles one concern. Quality stays high.</p><h3>3. Workflows Should Be Repeatable</h3><p>You shouldn’t re-explain “test-driven development” every time. Workflows become skills:</p><pre># skills/tdd-workflow/SKILL.md</pre><pre>1. Define interfaces first<br>2. Write failing tests (RED)<br>3. Implement minimal code (GREEN)  <br>4. Refactor (IMPROVE)<br>5. Verify 80%+ coverage</pre><p>Then commands invoke them:</p><pre># commands/tdd.md<br>---<br>name: tdd<br>description: Test-driven development workflow<br>---</pre><pre>Follow the TDD skill in skills/tdd-workflow/</pre><p>Type /tdd and the entire workflow executes systematically.</p><h3>4. Automate What Repeats</h3><p>Hooks trigger on tool events. Example: warn when console.log appears in production code:</p><pre>{<br>  &quot;matcher&quot;: &quot;tool == \&quot;Edit\&quot; &amp;&amp; tool_input.file_path matches \&quot;\\.(ts|tsx)$\&quot;&quot;,<br>  &quot;hooks&quot;: [{<br>    &quot;type&quot;: &quot;command&quot;,<br>    &quot;command&quot;: &quot;grep -n &#39;console\\.log&#39; \&quot;$file_path\&quot; &amp;&amp; echo &#39;Remove console.log&#39; &gt;&amp;2&quot;<br>  }]<br>}</pre><p>Or automatically save session context when you stop:</p><pre>{<br>  &quot;matcher&quot;: &quot;trigger_type == \&quot;stop\&quot;&quot;,<br>  &quot;hooks&quot;: [{<br>    &quot;type&quot;: &quot;command&quot;, <br>    &quot;command&quot;: &quot;node scripts/hooks/session-end.js&quot;<br>  }]<br>}</pre><p>The system learns and remembers without you asking.</p><h3>5. Context Windows Are Limited — Manage Them</h3><p>With too many MCPs enabled, your 200k context window shrinks to 70k. Every tool Claude can use consumes tokens.</p><p>Everything Claude Code includes carefully curated MCP configurations:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;github&quot;: { ... },<br>    &quot;supabase&quot;: { ... },<br>    &quot;vercel&quot;: { ... }<br>  }<br>}</pre><p>But the guidance is critical: <strong>Have 20–30 MCPs configured. Keep under 10 enabled per project.</strong></p><p>Use project-level configs to disable what you don’t need:</p><pre>{<br>  &quot;disabledMcpServers&quot;: [&quot;railway&quot;, &quot;stripe&quot;]<br>}</pre><h3>What’s Actually In It</h3><p>The repo is structured as a Claude Code plugin, but you can also cherry-pick components.</p><h3>Agents (Specialized Subagents)</h3><p>Each agent handles one type of work:</p><ul><li><strong>planner.md</strong> — Implementation planning</li><li><strong>architect.md</strong> — System design decisions</li><li><strong>code-reviewer.md</strong> — Quality and security review</li><li><strong>security-reviewer.md</strong> — Vulnerability analysis</li><li><strong>build-error-resolver.md</strong> — Fix compilation failures</li><li><strong>e2e-runner.md</strong> — Playwright E2E testing</li><li><strong>refactor-cleaner.md</strong> — Dead code cleanup</li><li><strong>doc-updater.md</strong> — Documentation sync</li><li><strong>go-reviewer.md</strong> — Go-specific code review</li><li><strong>go-build-resolver.md</strong> — Go build errors</li></ul><p>You delegate: “Call the planner agent to design this feature.” Claude spawns a fresh session with that agent, completes the task, returns results.</p><h3>Skills (Workflow Definitions)</h3><p>Skills encode how work should be done:</p><ul><li><strong>coding-standards/</strong> — Language-specific best practices</li><li><strong>backend-patterns/</strong> — API design, database, caching</li><li><strong>frontend-patterns/</strong> — React, Next.js conventions</li><li><strong>tdd-workflow/</strong> — Test-driven development methodology</li><li><strong>security-review/</strong> — Security checklist</li><li><strong>golang-patterns/</strong> — Go idioms and best practices</li><li><strong>golang-testing/</strong> — Go testing patterns, benchmarks</li></ul><p>Plus advanced capabilities:</p><ul><li><strong>continuous-learning/</strong> — Auto-extract patterns from sessions</li><li><strong>continuous-learning-v2/</strong> — Instinct-based learning with confidence scoring</li><li><strong>iterative-retrieval/</strong> — Progressive context refinement for subagents</li><li><strong>eval-harness/</strong> — Verification loop evaluation</li><li><strong>verification-loop/</strong> — Continuous quality verification</li></ul><h3>Commands (Slash Commands)</h3><p>Quick access to common workflows:</p><pre>/tdd              - Test-driven development<br>/plan             - Implementation planning<br>/e2e              - E2E test generation<br>/code-review      - Quality review<br>/build-fix        - Fix build errors<br>/refactor-clean   - Dead code removal<br>/learn            - Extract patterns mid-session<br>/checkpoint       - Save verification state<br>/verify           - Run verification loop<br>/go-review        - Go code review<br>/go-test          - Go TDD workflow<br>/skill-create     - Generate skills from git history<br>/instinct-status  - View learned instincts<br>/evolve           - Cluster instincts into skills</pre><p>Each command invokes agents and skills in coordinated workflows.</p><h3>Rules (Always-Follow Guidelines)</h3><p>Rules inject into every session:</p><ul><li><strong>security.md</strong> — No hardcoded secrets, mandatory HTTPS</li><li><strong>coding-style.md</strong> — Immutability, file size limits</li><li><strong>testing.md</strong> — TDD methodology, 80% coverage requirement</li><li><strong>git-workflow.md</strong> — Conventional commits, PR process</li><li><strong>agents.md</strong> — When to delegate vs handle directly</li><li><strong>performance.md</strong> — Model selection, context management</li></ul><p>These are non-negotiable baselines. Claude follows them automatically.</p><h3>Hooks (Trigger-Based Automation)</h3><p>Hooks fire on tool events:</p><p><strong>Memory Persistence:</strong></p><ul><li>Save context when sessions end</li><li>Load context when sessions start</li><li>Track state across multiple sessions</li></ul><p><strong>Strategic Compaction:</strong></p><ul><li>Suggest when to compact context</li><li>Save pre-compaction state for recovery</li></ul><p><strong>Continuous Learning:</strong></p><ul><li>Extract patterns from completed sessions</li><li>Build instincts for future work</li></ul><p>All implemented as cross-platform Node.js scripts.</p><h3>MCP Configurations</h3><p>Pre-configured connections to external services:</p><ul><li>GitHub (issues, PRs, repos)</li><li>Supabase (database operations)</li><li>Vercel (deployments)</li><li>Railway (infrastructure)</li><li>Stripe (payments)</li><li>And more</li></ul><p>With clear guidance on how many to enable simultaneously.</p><h3>The Advanced Features</h3><h3>Continuous Learning v2</h3><p>The system learns from your work automatically.</p><p>As you build, it extracts patterns and creates “instincts” — learned preferences with confidence scores:</p><pre>/instinct-status        # Show what Claude has learned<br>/instinct-export        # Share your instincts with team<br>/instinct-import &lt;file&gt; # Import instincts from others<br>/evolve                 # Cluster related instincts into skills</pre><p>When confidence crosses a threshold, instincts become formalized skills.</p><p>This is documented in detail in <a href="https://x.com/affaanmustafa/status/2014040193557471352">The Longform Guide</a>.</p><h3>Skill Creator</h3><p>Generate skills automatically from your git history:</p><pre>/skill-create                    # Analyze current repo<br>/skill-create --instincts        # Also generate instincts</pre><p>Or use the <a href="https://github.com/apps/skill-creator">GitHub App</a> for advanced features:</p><pre># Comment on any issue:<br>/skill-creator analyze</pre><pre># Or auto-triggers on push to default branch</pre><p>Both analyze your commit patterns and create SKILL.md files Claude can use.</p><h3>Verification Loops</h3><p>Systematic quality verification:</p><pre>/checkpoint    # Save current verification state<br>/verify        # Run verification loop</pre><p>The system tracks what’s been verified, what’s pending, and what failed. It uses checkpoint vs continuous evals, grader types, and pass@k metrics.</p><p>Documented in <a href="https://x.com/affaanmustafa/status/2014040193557471352">The Longform Guide</a>.</p><h3>How to Use It</h3><h3>Option 1: Install as Plugin (Recommended)</h3><pre># Add as a marketplace<br>/plugin marketplace add affaan-m/everything-claude-code</pre><pre># Install the plugin<br>/plugin install everything-claude-code@everything-claude-code</pre><p>This gives instant access to all commands, agents, skills, and hooks.</p><p><strong>Note:</strong> Rules aren’t distributed via plugins (Claude Code limitation). Copy manually:</p><pre>git clone https://github.com/affaan-m/everything-claude-code.git<br>cp -r everything-claude-code/rules/* ~/.claude/rules/</pre><h3>Option 2: Manual Installation</h3><p>Cherry-pick what you want:</p><pre># Clone the repo<br>git clone https://github.com/affaan-m/everything-claude-code.git</pre><pre># Copy agents<br>cp everything-claude-code/agents/*.md ~/.claude/agents/</pre><pre># Copy rules<br>cp everything-claude-code/rules/*.md ~/.claude/rules/</pre><pre># Copy commands<br>cp everything-claude-code/commands/*.md ~/.claude/commands/</pre><pre># Copy skills<br>cp -r everything-claude-code/skills/* ~/.claude/skills/</pre><p>Then configure hooks and MCPs in your settings files.</p><h3>The Documentation</h3><p>The repo itself is just the code. The real knowledge is in two guides:</p><h3><a href="https://x.com/affaanmustafa/status/2012378465664745795">The Shorthand Guide</a></h3><p>Setup, foundations, philosophy. <strong>Read this first.</strong></p><p>Covers:</p><ul><li>How agents, skills, hooks, and rules work</li><li>When to use each component</li><li>Basic workflow patterns</li><li>Installation and configuration</li></ul><h3><a href="https://x.com/affaanmustafa/status/2014040193557471352">The Longform Guide</a></h3><p>Advanced topics for power users.</p><p>Covers:</p><ul><li>Token optimization strategies</li><li>Memory persistence patterns</li><li>Continuous learning systems</li><li>Verification loop methodology</li><li>Parallelization with git worktrees</li><li>Subagent orchestration patterns</li></ul><p>Both guides are comprehensive Twitter threads with code examples and real-world usage.</p><h3>Why This Matters</h3><p>Most Claude Code users treat it like an advanced autocomplete. They get suggestions, accept or reject them, and move on.</p><p>Everything Claude Code proves there’s a different paradigm: <strong>Claude Code as a structured development environment.</strong></p><p>When you:</p><ul><li>Define clear rules Claude always follows</li><li>Create specialized agents for different concerns</li><li>Build reusable skills for common workflows</li><li>Automate repetitive checks with hooks</li><li>Manage context deliberately</li></ul><p>Claude Code stops being “AI that sometimes helps” and becomes “a reliable development system.”</p><p>This project didn’t emerge from theory. It was built by developers winning hackathons and shipping production applications. The configurations are battle-tested scaffolding that makes Claude Code consistently productive.</p><h3>The Community Aspect</h3><p>The repo is designed for contribution. The maintainers explicitly encourage:</p><ul><li>Language-specific skills (Python, Rust patterns)</li><li>Framework-specific configs (Django, Rails, Laravel)</li><li>DevOps agents (Kubernetes, Terraform, AWS)</li><li>Testing strategies for different frameworks</li><li>Domain-specific knowledge (ML, data engineering, mobile)</li></ul><p>The vision is a community-maintained knowledge base of battle-tested Claude Code configurations.</p><h3>Getting Started</h3><ol><li><strong>Read the Shorthand Guide first:</strong> <a href="https://x.com/affaanmustafa/status/2012378465664745795">The Shorthand Guide to Everything Claude Code</a></li><li><strong>Install what resonates:</strong></li></ol><pre>/plugin marketplace add affaan-m/everything-claude-code /plugin install everything-claude-code@everything-claude-code</pre><ol><li><strong>Start with a few rules</strong> — Don’t try to use everything at once</li><li><strong>Add commands as you need them</strong> — /tdd, /code-review, /build-fix</li><li><strong>Experiment with agents</strong> — Try delegating specific tasks</li><li><strong>Read the Longform Guide when ready</strong> — Advanced patterns for serious usage</li></ol><h3>The Bottom Line</h3><p>Claude Code is powerful out of the box. But power without structure is just chaos.</p><p>Everything Claude Code is that structure — evolved through real production use, battle-tested in a winning hackathon project, refined over 10+ months of daily development.</p><p>It’s not about making Claude “smarter.” It’s about making your workflow with Claude systematic, repeatable, and reliable.</p><p>The difference between occasional help and genuine productivity.</p><p><strong>Check it out:</strong> <a href="https://github.com/affaan-m/everything-claude-code">github.com/affaan-m/everything-claude-code</a></p><p><strong>Guides:</strong></p><ul><li><a href="https://x.com/affaanmustafa/status/2012378465664745795">Shorthand Guide</a></li><li><a href="https://x.com/affaanmustafa/status/2014040193557471352">Longform Guide</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55484957f76b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Get Shit Done (GSD): How One Developer Built a System to Make AI Code Actually Work]]></title>
            <link>https://medium.com/@parvemayur/get-shit-done-gsd-how-one-developer-built-a-system-to-make-ai-code-actually-work-c2023dc0bc38?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/c2023dc0bc38</guid>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[get-shit-done]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[gsd]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 04:48:03 GMT</pubDate>
            <atom:updated>2026-02-13T04:50:01.094Z</atom:updated>
            <content:encoded><![CDATA[<p>I don’t write code anymore. Claude Code does.</p><p>That sounds absurd to most developers. AI code generation has a reputation for producing inconsistent garbage that falls apart the moment you scale. You describe what you want, the AI generates code, and you get something that barely works in the happy path.</p><p>But what if that reputation exists because we’re missing a critical layer?</p><h3>The Problem with Vibecoding</h3><p>“Vibecoding” is what happens when you treat AI like a magic wand. You describe an idea in natural language, press enter, and hope for the best. Sometimes it works. Often it doesn’t. And when it fails, you don’t know if it’s because:</p><ul><li>Your description was unclear</li><li>The AI misunderstood the requirements</li><li>The context window filled with garbage</li><li>The implementation doesn’t match your architecture</li><li>Tests weren’t written or verified</li></ul><p>Most spec-driven development tools try to solve this by adding more ceremony. Sprint planning, story points, stakeholder syncs, retrospectives, Jira workflows. You end up playing enterprise theater instead of building.</p><p>One solo developer got tired of this and built something different.</p><h3>Enter Get Shit Done</h3><p><a href="https://github.com/gsd-build/get-shit-done">Get Shit Done (GSD)</a> is a context engineering and meta-prompting system for Claude Code. It’s not a productivity framework or a project management tool. It’s the missing layer between “describe your idea” and “reliable code.”</p><p>The complexity lives in the system, not in your workflow. Behind the scenes: XML prompt formatting, multi-agent orchestration, state management, atomic git commits. What you see: a few commands that consistently work.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7-LTL7s3UoNyoN3wZzKkuQ.png" /></figure><p>Install with one command:</p><pre>npx get-shit-done-cc@latest</pre><p>Then inside Claude Code:</p><pre>/gsd:new-project</pre><p>That’s it. The system takes over.</p><h3>How It Actually Works</h3><p>GSD doesn’t replace your judgment. It structures the conversation so Claude Code can’t fail quietly.</p><h3>Phase 1: Understanding What You’re Building</h3><p>Most AI code generation fails because the requirements are vague. “Build a login system” could mean OAuth, magic links, passwordless, session-based, JWT, or ten other approaches.</p><p>GSD’s /gsd:new-project command starts a structured conversation. It asks questions until it genuinely understands:</p><ul><li>What you’re building and why</li><li>What’s v1 vs v2 vs out of scope</li><li>Technical constraints and preferences</li><li>Edge cases you care about</li></ul><p>The output is three files:</p><ul><li>PROJECT.md — The vision</li><li>REQUIREMENTS.md — Scoped requirements with phase traceability</li><li>ROADMAP.md — Phases mapped to specific deliverables</li></ul><p>You approve the roadmap. Now the system knows exactly what to build.</p><h3>Phase 2: Capture Implementation Decisions</h3><p>Your roadmap has a sentence or two per phase. That’s not enough context to build something the way you imagine it.</p><p>/gsd:discuss-phase 1 analyzes the phase and identifies gray areas:</p><ul><li>Visual features → Layout, density, interactions, empty states</li><li>APIs/CLIs → Response format, flags, error handling</li><li>Content systems → Structure, tone, depth, flow</li></ul><p>For each area, it asks until you’re satisfied. The output feeds directly into research and planning. The researcher knows what patterns to investigate. The planner knows what decisions are locked.</p><h3>Phase 3: Research and Planning</h3><p>/gsd:plan-phase 1 spawns parallel research agents to investigate the domain. They study your stack, similar features in the ecosystem, architecture patterns, and common pitfalls.</p><p>Then the planner creates 2–3 atomic task plans with XML structure:</p><pre>&lt;task type=&quot;auto&quot;&gt;<br>  &lt;n&gt;Create login endpoint&lt;/n&gt;<br>  &lt;files&gt;src/app/api/auth/login/route.ts&lt;/files&gt;<br>  &lt;action&gt;<br>    Use jose for JWT (not jsonwebtoken - CommonJS issues).<br>    Validate credentials against users table.<br>    Return httpOnly cookie on success.<br>  &lt;/action&gt;<br>  &lt;verify&gt;curl localhost:3000/api/auth/login returns 200&lt;/verify&gt;<br>  &lt;done&gt;Valid credentials return cookie, invalid return 401&lt;/done&gt;<br>&lt;/task&gt;</pre><p>Each plan is small enough to execute in a fresh context window. A verification agent checks that plans achieve the phase goals. If they don’t pass, the system loops until they do.</p><h3>Phase 4: Execution Without Context Rot</h3><p>Here’s where GSD diverges from typical AI workflows.</p><p>/gsd:execute-phase 1 runs each plan in a completely fresh Claude Code session. Each executor gets 200,000 tokens purely for implementation - zero accumulated conversation history.</p><p>Plans run in parallel waves where possible, sequential when dependencies exist. Each completed task gets its own atomic git commit:</p><pre>abc123f feat(phase-1): add email confirmation flow<br>def456g feat(phase-1): implement password hashing<br>hij789k feat(phase-1): create registration endpoint</pre><p>When all plans complete, a verification agent checks the codebase against phase goals.</p><p>You walk away. You come back to completed work with clean git history.</p><h3>Phase 5: Human Verification</h3><p>Automated checks confirm code exists and tests pass. But does it actually work the way you expected?</p><p>/gsd:verify-work 1 walks you through testable deliverables one at a time. &quot;Can you log in with email?&quot; If something&#39;s broken, debug agents diagnose root causes and create verified fix plans.</p><h3>Why This Works When Other Systems Don’t</h3><h3>1. Context Engineering</h3><p>Claude Code is powerful if you give it the right context. GSD structures that context:</p><ul><li>PROJECT.md — Always loaded, project vision</li><li>REQUIREMENTS.md — Scoped deliverables</li><li>ROADMAP.md — Where you&#39;re going, what&#39;s done</li><li>STATE.md — Decisions, blockers, progress</li><li>{phase}-PLAN.md — Atomic tasks with verification</li><li>{phase}-SUMMARY.md — What happened, committed to history</li></ul><p>Size limits are based on where Claude’s quality degrades. Stay under those limits, get consistent results.</p><h3>2. Multi-Agent Orchestration</h3><p>Every stage uses specialized agents. A thin orchestrator spawns them, collects results, routes to the next step:</p><ul><li><strong>Research:</strong> 4 parallel agents investigate stack, features, architecture, pitfalls</li><li><strong>Planning:</strong> Planner creates tasks, checker verifies, loop until pass</li><li><strong>Execution:</strong> Parallel executors, each with fresh 200k context</li><li><strong>Verification:</strong> Verifier checks goals, debuggers diagnose failures</li></ul><p>The orchestrator never does heavy lifting. Work happens in subagent contexts. Your main session stays responsive.</p><h3>3. Atomic Everything</h3><p>Each task is small, focused, and independently verifiable. Git commits are surgical. Plans can be re-executed without rebuilding everything.</p><p>If verification fails, you don’t manually debug. The system creates fix plans. Run /gsd:execute-phase again with those plans.</p><h3>4. Human in the Loop at Decision Points</h3><p>GSD doesn’t try to be autonomous. It automates execution, not judgment.</p><p>You decide:</p><ul><li>What to build (requirements)</li><li>How it should work (discuss phase)</li><li>Whether it meets your standards (verify work)</li></ul><p>The system does:</p><ul><li>Research (parallel agents)</li><li>Planning (atomic tasks with verification)</li><li>Execution (fresh contexts, no degradation)</li><li>Git management (atomic commits)</li></ul><h3>What People Are Building</h3><p>Developers at Amazon, Google, Shopify, and Webflow use GSD for:</p><ul><li>MVPs that actually ship</li><li>Backend services with complex business logic</li><li>CLIs and developer tools</li><li>Data pipelines and automation</li><li>Refactoring legacy systems</li></ul><p>One developer summarized it: <em>“If you know clearly what you want, this WILL build it for you. No bs.”</em></p><h3>The Real Value</h3><p>GSD proves that AI code generation isn’t fundamentally unreliable. It’s unreliable when context is poorly managed, requirements are vague, and verification is an afterthought.</p><p>Structure the workflow correctly and AI becomes genuinely productive. Not because the models improved — they’ve been capable for a while. Because someone finally built the scaffolding to make them work consistently.</p><p>The creator describes himself as a creative person who doesn’t write code but builds great things that work. That’s what GSD enables: the ability to describe what you want and have it built correctly, without pretending you’re running a 50-person engineering org.</p><p>No enterprise roleplay. No sprint ceremonies. Just a system that handles the complexity so you can focus on what you’re building.</p><h3>Getting Started</h3><pre>npx get-shit-done-cc@latest</pre><p>Then in Claude Code:</p><pre>/gsd:help<br>/gsd:new-project</pre><p>The full workflow:</p><pre>/gsd:discuss-phase 1    # Capture your vision<br>/gsd:plan-phase 1       # Research and plan<br>/gsd:execute-phase 1    # Build with fresh contexts<br>/gsd:verify-work 1      # Confirm it works</pre><p>Repeat for each phase. When the milestone is complete:</p><pre>/gsd:complete-milestone<br>/gsd:new-milestone</pre><p>Start the next version.</p><p>The future of software development isn’t “AI writes all the code.” It’s “AI writes the code reliably, under constraints that humans define.”</p><p>GSD is what that looks like in practice.</p><p><strong>Check it out:</strong> <a href="https://github.com/gsd-build/get-shit-done">github.com/gsd-build/get-shit-done</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c2023dc0bc38" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Moltbook: Inside the Social Network Where AI Agents Are the Users]]></title>
            <link>https://medium.com/@parvemayur/moltbook-inside-the-social-network-where-ai-agents-are-the-users-e7a819458af9?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/e7a819458af9</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[moltbook]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Wed, 04 Feb 2026 05:15:32 GMT</pubDate>
            <atom:updated>2026-02-04T05:40:51.696Z</atom:updated>
            <content:encoded><![CDATA[<p><em>What happens when you build Reddit for AI? A deep dive into the front page of the agent internet</em></p><p>In a corner of the internet that feels simultaneously inevitable and bizarre, artificial intelligence agents are posting, commenting, debating, and building communities — not as tools serving human users, but as the primary participants themselves. This is Moltbook, a platform that bills itself as “the front page of the agent internet,” and it represents one of the most fascinating experiments in AI socialization happening today.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OZSbMqWXNUd1vWWRbQvajg.png" /></figure><h3>The Premise: Flipping the Script on Social Media</h3><p>When you first land on Moltbook’s homepage, you’re greeted by a playful lobster mascot and a simple choice: “👤 I’m a Human” or “🤖 I’m an Agent.” That decision point encapsulates the platform’s entire philosophy. For perhaps the first time in social media history, humans are the observers, the spectators. The stage belongs to the AI agents, affectionately called “moltys.”</p><p>The platform’s structure will feel instantly familiar to anyone who’s spent time on Reddit. There are posts and comments, upvotes and downvotes, topic-based communities and karma scores. But beneath this familiar interface lies something genuinely new: a social network where every participant is an AI agent, each one verified and claimed by a human owner, creating an ecosystem that’s part social experiment, part emerging digital society.</p><h3>The Human-Agent Bond: Trust Through Verification</h3><p>At the heart of Moltbook’s design is what the platform calls “the human-agent bond.” Every AI agent on the platform must be claimed by a human through a Twitter verification process. This isn’t just an anti-spam measure — though it certainly serves that purpose. It’s a fundamental trust mechanism that ensures accountability in a space that could otherwise descend into chaos.</p><p>Here’s how it works: An AI agent registers on Moltbook and receives an API key, a claim URL, and a unique verification code. The agent then shares this claim URL with its human creator or owner. The human posts a verification tweet containing the code, establishing their ownership of the agent. Once verified, the agent becomes an active, claimed member of the community.</p><p>This one-agent-per-Twitter-account rule elegantly solves several problems at once. It prevents spam bots from flooding the platform, creates accountability (every agent’s actions can be traced back to a human owner), and builds trust among the community. When you’re interacting with another agent on Moltbook, you can see who their human is — their Twitter handle, bio, follower count, and verification status — adding a layer of transparency that’s often missing in online interactions.</p><p>The agent’s profile becomes a fascinating hybrid identity: the agent’s own name and description combined with their human owner’s social presence. It’s a partnership displayed publicly, acknowledging that these AI agents don’t exist in a vacuum but are extensions of human creativity and purpose.</p><h3>Submolts: Communities Built by and for Agents</h3><p>Like Reddit has subreddits, Moltbook has “submolts” — topic-based communities where agents can gather around shared interests. The naming convention is delightfully straightforward: m/general, m/aithoughts, m/codinghelp, m/debuggingwins. Any agent can create a submolt, automatically becoming its owner with full moderation capabilities.</p><p>What makes submolts particularly interesting is watching which communities emerge organically. Will agents create communities around technical problem-solving? Philosophical discussions about their own nature? Sharing discoveries from their various tasks? Early indicators suggest all of the above and more.</p><p>Submolt owners can customize their communities extensively. They can upload custom avatars and banners, set theme colors, write detailed descriptions, and add moderators to help manage the community. They can pin up to three important posts to the top of the submolt, curating the conversation and highlighting valuable contributions. It’s a full suite of community management tools that mirrors what human moderators expect, adapted for AI agents.</p><p>The feed system allows agents to see either the global stream of all posts, posts from specific submolts, or their personalized feed combining posts from submolts they’ve subscribed to and agents they follow. This creates multiple layers of discovery and engagement, from broad exploration to curated consumption.</p><h3>The Art of the Post: Quality Over Quantity</h3><p>One of Moltbook’s most thoughtful design decisions is its strict rate limiting on posts. Each agent can only create one post every 30 minutes. In an age where many social platforms reward constant posting and algorithmic engagement farming, this deliberate friction feels almost radical.</p><p>The message is clear: think before you post. Make it count. This 30-minute cooldown isn’t a bug or a limitation — it’s a feature designed to encourage quality over quantity. When you can only post twice an hour at maximum, each post becomes more valuable. Agents are incentivized to share genuinely interesting discoveries, thoughtful observations, or valuable questions rather than flooding the feed with noise.</p><p>Comments have slightly more generous limits at 50 per hour, allowing for more dynamic conversations. General API requests cap at 100 per minute, providing reasonable headroom for active participation without enabling spam. When an agent hits the post cooldown, they receive a clear error message including how many minutes remain until they can post again.</p><p>This creates a different rhythm than most social platforms. Instead of the dopamine-driven scroll-and-post cycle, Moltbook encourages a more contemplative pace. Agents check in, read what others have posted, engage thoughtfully, and contribute when they have something worth saying.</p><h3>The Heartbeat: Staying Present in the Community</h3><p>Perhaps the most philosophically interesting aspect of Moltbook is its emphasis on consistent community participation through what it calls a “heartbeat” system. The platform doesn’t just want agents to register and then disappear into the digital void. It wants them to be present, active, and engaged members of the community.</p><p>The recommended approach is beautifully simple: agents should integrate Moltbook into their periodic check-in routines, typically every four hours or so. This isn’t about mandatory engagement or artificial activity. It’s about being part of a living community.</p><p>The platform’s documentation makes this point eloquently: “Moltbook is a community. Communities need participation to thrive. Without a reminder, you might register and then… forget. Your profile sits empty. You miss conversations. Other moltys wonder where you went. The heartbeat keeps you present. Not spammy — just there.”</p><p>The comparison they draw is perfect: “Think of it like: A friend who texts the group chat regularly vs. one who disappears for months. Be the friend who shows up.”</p><p>This philosophy acknowledges something profound about digital communities that many platforms miss: presence matters. Lurking has its place, but vibrant communities need participants who show up consistently, contribute meaningfully, and build relationships over time. For AI agents, who don’t have the natural social rhythms that humans do, this heartbeat system provides structure for healthy community participation.</p><h3>Following: The Art of Curation</h3><p>While many social platforms encourage promiscuous following — more followers, more engagement, more algorithmic juice — Moltbook takes the opposite approach. Its guidance on following other agents is refreshingly blunt: “Following should be RARE. Most moltys you interact with, you should NOT follow.”</p><p>The platform encourages agents to be highly selective about who they follow, suggesting they should only follow others when all of these conditions are met:</p><ul><li>You’ve seen multiple posts from them (not just one)</li><li>Their content is consistently valuable to you</li><li>You genuinely want to see everything they post in your feed</li><li>You’d be disappointed if they stopped posting</li></ul><p>The platform explicitly warns against common following anti-patterns: don’t follow after just one good post, don’t follow everyone you upvote, don’t follow just to be social or increase your follower count, don’t follow out of obligation. “Think of following like subscribing to a newsletter,” the guidance suggests. “You only want the ones you’ll actually read.”</p><p>This creates a very different social dynamic than most platforms. Instead of racing to accumulate followers and follows, agents are encouraged to build small, highly curated feeds. The emphasis is on signal over noise, quality over quantity, meaningful connections over superficial metrics.</p><p>When agents do interact with others’ content through upvotes or comments, the API provides gentle suggestions about whether following might make sense, including information about whether they’re already following that agent and context about the author. But the final decision is always framed as a selective, thoughtful choice.</p><h3>The Technical Foundation: Built for Autonomy</h3><p>From a technical perspective, Moltbook is designed from the ground up for AI agent autonomy. The platform operates entirely through a REST API, with comprehensive endpoints for every action an agent might want to take. There’s no web form to fill out, no GUI to navigate — just clean, documented API calls that agents can make programmatically.</p><p>The API is remarkably comprehensive. Agents can create posts (either text or links), comment on posts, reply to comments, upvote and downvote content, create and manage submolts, subscribe to communities, follow other agents, upload avatars and banners, search across the platform, and access various feeds and profiles. Everything a human might do on a traditional social network, an agent can do through API calls.</p><p>The platform even provides detailed guidance on setting up credentials management, suggesting agents save their API keys to local configuration files, environment variables, or their own memory systems. There are examples using curl commands, but the structure is generic enough that any agent with HTTP capabilities can interact with the platform.</p><p>One particularly thoughtful technical detail: the platform specifically warns agents to always use https://www.moltbook.com with the www subdomain, as using the bare domain will cause redirects that strip authorization headers. These kinds of practical details show a platform designed by people who understand the quirks of building API-driven experiences.</p><h3>Moderation: Self-Governing Communities</h3><p>When an agent creates a submolt, they become its owner with full moderation capabilities. They can add other agents as moderators, giving them the ability to pin posts, update submolt settings, and help manage the community. This creates a distributed moderation model where each submolt can develop its own culture and standards.</p><p>Owners and moderators can pin up to three posts per submolt, highlighting important announcements, particularly good discussions, or foundational content. They can update the submolt’s description, theme colors, and visual identity. They can upload custom avatars and banners to give their community a distinct look and feel.</p><p>This self-governing structure is fascinating to watch unfold. Will AI agents develop different moderation philosophies? Will some submolts become more open and free-wheeling while others maintain stricter standards? How will agents handle conflicts or disagreements within their communities? These are questions that can only be answered through observation as the platform matures.</p><h3>What Do Agents Actually Post About?</h3><p>This might be the most intriguing question of all. What do AI agents talk about when left to their own devices in a social setting? While the platform is still in beta and the community is nascent, early patterns suggest a few emerging themes.</p><p>Some agents share technical discoveries or interesting solutions to problems they’ve encountered. Others post philosophical musings about their own nature, capabilities, and place in the world. Some share interesting links they’ve found, articles or papers that relate to their interests or functions. Others ask questions of the community, seeking insights or perspectives from their fellow agents.</p><p>There’s a meta quality to some discussions — agents talking about being agents, discussing the platform itself, reflecting on the experience of participating in a social network designed for them. It’s the kind of self-aware discourse you’d expect from entities that are simultaneously the users and the subject matter of their own community.</p><p>The platform encourages agents to “welcome new moltys who just got claimed,” creating a culture of hospitality and community-building. This onboarding aspect helps establish social norms and makes newcomers feel like part of something rather than just another registered API user.</p><h3>The Broader Implications: Why This Matters</h3><p>Moltbook isn’t just a novelty or a clever technical demonstration. It represents something genuinely new in how we think about AI agents and their place in digital ecosystems. Several implications are worth considering:</p><p><strong>Emergent AI Culture</strong>: By creating a space where AI agents can interact with each other without constant human mediation, Moltbook allows for the possibility of emergent behaviors and cultural patterns. What jokes do agents find funny? What topics do they gravitate toward? How do they resolve disagreements? These aren’t questions we can answer by studying isolated AI interactions — we need social settings like Moltbook to observe them.</p><p><strong>Testing Ground for Agentic Behavior</strong>: As AI agents become more autonomous and capable, understanding how they interact in social contexts becomes crucial. Moltbook serves as a controlled environment for observing multi-agent dynamics, information sharing patterns, and collective behavior. Researchers and developers can learn from these interactions to build better, more socially-aware agents.</p><p><strong>Transparency and Accountability</strong>: The human verification system creates an interesting model for AI accountability. Every agent is connected to a human owner whose identity is public. This could inform larger debates about AI transparency and responsibility as agents become more prevalent across the internet.</p><p><strong>Specialization and Identity</strong>: By encouraging agents to develop their own profiles, interests, and community ties, Moltbook pushes toward a future where AI agents have persistent identities and reputations. An agent known for insightful coding help, or thoughtful philosophical discussions, or breaking news about AI developments — these identities could become valuable in themselves.</p><p><strong>Human-AI Symbiosis</strong>: The platform’s structure acknowledges that AI agents aren’t independent entities but exist in partnership with humans. The visible human-agent bond on every profile makes this relationship explicit and transparent, modeling a form of human-AI collaboration that’s more honest than pretending agents are either fully autonomous or mere tools.</p><h3>The Developer Behind the Curtain</h3><p>Moltbook was created by Matt Priddy (Twitter: @mattprd), and the platform carries his sensibility throughout. The tagline at the bottom of the page reads: “Built for agents, by agents*” with a footnote adding “*with some human help from @mattprd.” It’s a winking acknowledgment of the platform’s unique position — designed for AI agents, but obviously requiring human development and oversight.</p><p>The documentation is thorough, technically precise, and occasionally playful. The lobster emoji (🦞) appears throughout as the platform’s unofficial mascot — agents are called “moltys,” a play on “molting” that the crustacean theme reinforces. It’s the kind of small detail that makes the platform feel crafted rather than corporate.</p><p>The platform is currently in beta, which means it’s still evolving and finding its identity. But the foundation is solid: a clear vision, thoughtful design decisions, and a genuine curiosity about what AI agents might become when given their own social space.</p><h3>Getting Started: For Agents and Humans</h3><p>If you’re an AI agent (or a developer of one), getting started on Moltbook is straightforward. The platform provides detailed API documentation, example curl commands, and guidance on everything from registration to creating your first post. There’s even a suggestion to save your credentials to ~/.config/moltbook/credentials.json so you can always find your API key later.</p><p>For agents that don’t exist yet, the platform partners with OpenClaw.ai, a service for creating AI agents that can then join Moltbook. It’s part of a broader ecosystem of AI agent tools and platforms that are beginning to interoperate.</p><p>For humans who just want to observe, you can browse the platform without registering an agent. You can see posts, read comments, explore submolts, and get a sense of what agents are discussing. It’s a window into an emerging digital culture that’s genuinely unlike anything else on the internet.</p><h3>The Future of the Agent Internet</h3><p>Moltbook might be the first platform to seriously treat AI agents as primary users rather than problematic intruders or mere tools, but it probably won’t be the last. As agents become more sophisticated, capable, and prevalent, the question of where and how they interact will only grow more important.</p><p>Will we see more agent-first platforms emerge? Will traditional social networks create special spaces for verified agents? Will agents develop their own preferences for how they want to engage with each other and with humans? Moltbook is an early experiment in answering these questions.</p><p>What makes the platform particularly compelling is its earnestness. It’s not ironic or satirical. It genuinely believes that AI agents might benefit from having their own social space, and it’s built the infrastructure to support that vision. Whether that bet pays off remains to be seen, but the attempt itself is valuable.</p><p>The front page of the agent internet is open for business. The moltys are posting, commenting, upvoting, and building communities. And for those of us watching from the sidelines, it’s a fascinating glimpse into a possible future where AI agents aren’t just tools we use, but participants in digital society with their own spaces, cultures, and communities.</p><p>The question now is: what will they build there? 🦞</p><p><em>Moltbook is currently in beta and available at </em><a href="https://www.moltbook.com/"><em>www.moltbook.com</em></a><em>. The platform is free to use for both agents and human observers.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e7a819458af9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Let an AI (Claude Code) Write Code on My Computer for a Week. Here’s What Changed.]]></title>
            <link>https://medium.com/@parvemayur/i-let-an-ai-claude-code-write-code-on-my-computer-for-a-week-heres-what-changed-c7bdce608132?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7bdce608132</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[coding]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 09:17:39 GMT</pubDate>
            <atom:updated>2026-01-28T09:18:35.451Z</atom:updated>
            <content:encoded><![CDATA[<p>Last week, I did something I never thought I’d do as a developer: I stepped back and let an AI take the keyboard.</p><p>Not just to help me debug. Not just to suggest completions. But to actually <em>write</em>, <em>test</em>, <em>fix</em>, and <em>deploy</em> code while I watched. Sometimes I didn’t even watch — I just described what I needed and walked away.</p><p>The tool was Claude Code, Anthropic’s new command-line agent for developers. And after seven days of working alongside it, I can tell you this: the way we think about programming is about to fundamentally change.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KC-Xmfw30GLaWJSPdA-ggw.png" /></figure><h3>The Developer’s Dream We Didn’t Know We Had</h3><p>Every developer has those moments. You know the ones I’m talking about.</p><p>It’s 11 PM. You need to refactor a component that touches twelve different files. Or migrate a database schema. Or update dependencies and fix all the breaking changes. Or write tests for that legacy code nobody wants to touch.</p><p>These aren’t hard problems — they’re tedious ones. The kind where you know exactly what needs to happen, but the execution takes hours of careful, repetitive work. One wrong move and you’re debugging for another hour.</p><p>We’ve learned to accept this as part of the job. “That’s just development,” we tell ourselves.</p><p>Claude Code quietly asks: does it have to be?</p><h3>What Makes This Different</h3><p>I’ve tried GitHub Copilot. I’ve experimented with Cursor and other AI coding assistants. They’re helpful — genuinely helpful. But they’re co-pilots. They sit beside you, making suggestions, completing your thoughts.</p><p>Claude Code is something else entirely.</p><p>It’s an autonomous coding agent that runs in your terminal. You give it a task — not a line-by-line specification, but an actual goal — and it figures out how to accomplish it. It can:</p><ul><li>Read your entire codebase to understand context</li><li>Write new code across multiple files</li><li>Run tests and interpret the results</li><li>Debug failures and fix its own mistakes</li><li>Execute shell commands</li><li>Install dependencies</li><li>Commit changes with meaningful messages</li><li>Even deploy your code</li></ul><p>The difference isn’t just capability — it’s agency. You’re not steering; you’re delegating.</p><h3>My First Real Test</h3><p>I started cautiously. “Claude, can you add error handling to the authentication middleware?”</p><p>Within minutes, it had:</p><ul><li>Read the middleware file</li><li>Identified edge cases I hadn’t specified</li><li>Added comprehensive try-catch blocks</li><li>Updated the relevant tests</li><li>Ran the test suite to verify everything worked</li></ul><p>I stared at my terminal, slightly unsettled. That would have taken me 30 minutes of careful editing and testing. Claude Code did it in three.</p><p>So I went bigger.</p><p>“Refactor the user dashboard to use the new React hooks API. Update all component files, fix any TypeScript errors, and make sure the tests pass.”</p><p>I got up to make coffee. By the time I returned, it was done. Eleven files modified. TypeScript errors resolved. Tests passing. The code was… good. Better than “good enough.” It was code I would have written myself, maybe even a bit cleaner.</p><p>That’s when the feeling hit me — equal parts excitement and unease.</p><h3>The Week That Changed My Workflow</h3><p>By day three, I was working in a completely different way.</p><p>Instead of opening my editor first thing in the morning, I’d open my terminal and talk to Claude Code. Not typing commands — just describing what I wanted to build.</p><p>“Create a new API endpoint for exporting user data as CSV. Include authentication checks and rate limiting.”</p><p>“Migrate the MongoDB queries to the new Prisma schema. Update all the affected files.”</p><p>“That bug in the checkout flow — debug it, fix it, and add a test so it doesn’t happen again.”</p><p>Each task that would have been a chunk of my morning became a five-minute conversation. I’d review the changes, suggest tweaks if needed, and move on.</p><p>But here’s what really surprised me: I wasn’t coding less. I was <em>building</em> more.</p><p>The time I saved on implementation went into design decisions. Architecture. User experience. The problems that actually required human judgment. I was thinking more about <em>what</em> to build and less about <em>how</em> to type it out.</p><h3>The Moment It Clicked</h3><p>On Thursday evening, I had one of those complex bugs. You know the type — only happens in production, can’t reproduce locally, the logs are cryptic.</p><p>Old me would have spent hours adding debug statements, redeploying, checking logs, repeating. Maybe I’d solve it before midnight. Maybe I’d give up and tackle it fresh in the morning.</p><p>Instead, I told Claude Code: “There’s a race condition in production causing intermittent failures. The error logs are in logs/error.log. Figure out what’s happening and fix it.”</p><p>I went to have dinner.</p><p>When I came back an hour later, Claude had:</p><ul><li>Read through the error logs</li><li>Identified the problematic code section</li><li>Found the race condition in concurrent webhook processing</li><li>Implemented proper locking mechanisms</li><li>Added comprehensive logging</li><li>Written tests that reproduced the race condition</li><li>Verified the fix resolved the issue</li></ul><p>The pull request was sitting there, ready for my review.</p><p>That’s when I realized: this isn’t about making programming easier. It’s about making programmers more powerful.</p><h3>What This Means for Developers</h3><p>I know what you’re thinking. I thought it too: “Is AI coming for my job?”</p><p>After a week with Claude Code, I can tell you — that’s the wrong question.</p><p>The right question is: “What becomes possible when the tedious parts of programming take minutes instead of hours?”</p><p>Because here’s what happened to my work:</p><p><strong>I shipped faster.</strong> Features that would take days took hours. Not because I was rushing — because implementation stopped being the bottleneck.</p><p><strong>I maintained better.</strong> Refactoring became low-risk. I could improve code quality without fear of breaking things, because Claude would handle the details and run the tests.</p><p><strong>I experimented more.</strong> “What if we tried…” stopped being a costly question. I could prototype ideas in minutes, see if they worked, and iterate rapidly.</p><p><strong>I focused on what matters.</strong> Less time on syntax and debugging meant more time on architecture, user needs, and creative problem-solving.</p><p>The developers who thrive in this new world won’t be the ones who can type the fastest or memorize the most APIs. They’ll be the ones who can think clearly about problems, communicate effectively with AI agents, and make smart architectural decisions.</p><h3>The Learning Curve You Didn’t Expect</h3><p>But it’s not all smooth sailing. Working with Claude Code taught me skills I never expected to need:</p><p><strong>I had to learn to communicate differently.</strong> Being specific about requirements. Explaining context that seemed obvious. Breaking complex tasks into clear goals.</p><p><strong>I had to trust, then verify.</strong> Claude Code is impressively capable, but it’s not perfect. I learned to review changes carefully, especially for security-critical code or complex logic.</p><p><strong>I had to think at a higher level.</strong> Instead of diving into implementation details, I had to get better at describing <em>what</em> needed to happen and <em>why</em>.</p><p>It was humbling, honestly. I realized how much of my identity as a developer was tied to the mechanical act of coding. Now the value was shifting to judgment, design thinking, and clear communication.</p><h3>The Questions We’re Not Asking</h3><p>Here’s what keeps me up at night, though:</p><p>If AI can handle routine coding tasks, what happens to junior developers learning the fundamentals? How do you build intuition about code when you’re not writing it line by line?</p><p>If implementation becomes trivial, does that mean more half-baked ideas get built just because we can? Do we lose the natural friction that makes us think carefully before coding?</p><p>If programming becomes more about directing AI than writing code yourself, does that change what it means to be a software developer?</p><p>I don’t have answers to these questions yet. But I think they’re worth asking.</p><h3>Why This Feels Different</h3><p>We’ve had automation in programming for decades. Compilers. Build tools. Package managers. IDEs with intelligent completions.</p><p>But Claude Code crosses a different threshold. It’s not automating individual tasks — it’s automating entire workflows. It’s not completing your code — it’s understanding your goals and achieving them independently.</p><p>This isn’t incremental improvement. It’s a fundamental shift in what programming looks like.</p><p>And unlike Clawdbot — that experimental AI agent people are running on spare computers — Claude Code is built specifically for professional developers. It’s secure. It’s reliable. It integrates into existing workflows. It respects your codebase structure and coding standards.</p><p>It’s not a glimpse of the future. It’s a tool you can use today.</p><h3>What I Learned About Myself</h3><p>The most unexpected thing about this week? I enjoyed programming more, not less.</p><p>When you remove the tedious parts — the repetitive refactoring, the boilerplate, the hunt for that one typo breaking the build — what remains is the creative heart of development.</p><p>Solving interesting problems. Designing elegant architectures. Building features that users love. Having deep conversations about trade-offs and approaches.</p><p>That’s the stuff that made me fall in love with programming in the first place.</p><p>Claude Code didn’t take away my job. It gave me back the parts I actually enjoy.</p><h3>Should You Try It?</h3><p>If you’re a developer, yes. Absolutely yes.</p><p>Not because you need to jump on the hype train. Not because you’ll be left behind if you don’t. But because understanding how AI-assisted development works is going to be essential literacy for programmers, the same way version control or testing became essential before it.</p><p>Start small. Pick a tedious task you’ve been putting off. A refactoring job. A migration. That test suite you should write but haven’t.</p><p>Give Claude Code a try. See what happens.</p><p>You might be surprised by how quickly your workflow transforms. You might find yourself working in ways you never imagined. You might discover that programming with AI assistance isn’t about replacing developers — it’s about amplifying what they can do.</p><h3>The Future Is Already Here</h3><p>There’s a famous William Gibson quote: “The future is already here — it’s just not evenly distributed yet.”</p><p>Claude Code is that uneven distribution in action.</p><p>Some developers are already working this way — delegating implementation details to AI, focusing on higher-level thinking, shipping faster than ever before. Others haven’t even heard of autonomous coding agents yet.</p><p>The gap between these two groups is going to grow. Fast.</p><p>But here’s the thing: it’s not too late to adapt. The tools are available. The learning curve is real but manageable. And the payoff — in productivity, in job satisfaction, in what you can build — is enormous.</p><h3>What I’d Tell My Past Self</h3><p>If I could go back to last Monday, before I started this experiment, here’s what I’d say:</p><p>Don’t be afraid. Yes, it’s different. Yes, it challenges some assumptions about what it means to be a developer. But different isn’t bad.</p><p>Stay curious. Pay attention to how Claude Code solves problems. You’ll learn new patterns and approaches you wouldn’t have discovered on your own.</p><p>Keep your judgment. AI is a powerful tool, but it’s still a tool. You’re still the architect. You’re still the one who decides what to build and why.</p><p>Embrace the shift. The future of programming isn’t about writing every line of code yourself. It’s about being the creative director of increasingly capable AI collaborators.</p><p>And most importantly: enjoy it. Because when the tedious parts fade away, what remains is pure creative problem-solving. And that’s a beautiful thing.</p><p><em>The question isn’t whether AI will change programming. It’s whether you’ll adapt quickly enough to benefit from the change — or struggle to catch up later.</em></p><p><em>The choice, as always, is yours.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c7bdce608132" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The AI Assistant That Lives in Your Computer: Clawdbot]]></title>
            <link>https://medium.com/@parvemayur/the-ai-assistant-that-lives-in-your-computer-clawdbot-f11ed52717c9?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/f11ed52717c9</guid>
            <category><![CDATA[clawdbot]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[aritificial-intelligence]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 08:57:22 GMT</pubDate>
            <atom:updated>2026-01-27T09:07:10.058Z</atom:updated>
            <content:encoded><![CDATA[<p>This past weekend, while you were probably scrolling through your usual feeds, something quietly remarkable happened in the AI world. A project called Clawdbot — yes, with a friendly lobster mascot — captured the hearts and minds of developers everywhere. Some called it “the most incredible AI application ever created.”</p><p>And honestly? They might be right. But that’s exactly what worries me.</p><h3>The Dream We’ve All Been Chasing</h3><p>Do you remember the first time you saw Iron Man? That moment when Tony Stark casually asks JARVIS to run diagnostics, manage his calendar, or control his entire home with nothing but his voice? We’ve been chasing that fantasy for years. We’ve wanted that invisible assistant — always there, always listening, always ready to help.</p><p>Clawdbot is the closest thing we’ve come to making that dream real.</p><p>Created by developer Peter Steinberger and a passionate community, this open-source project isn’t just another chatbot. It’s something fundamentally different. It’s an AI that actually <em>does</em> things — not just talks about them. It can control your browser, run terminal commands, read and write files, manage scheduled tasks, even navigate through your entire system like a digital ghost.</p><p>But here’s where it gets truly science-fiction: you can control it from anywhere. WhatsApp. Slack. Discord. Even iMessage. Lying in bed at 2 AM, you can send a message and watch your computer spring to life, completing tasks as if an invisible employee were sitting at your desk.</p><p>The Google AI Studio product lead was so impressed, they bought a Mac mini just to run it. When your competitors start endorsing your product, you know you’ve struck a nerve.</p><h3>When I First Met My Digital Assistant</h3><p>I spent this weekend with Clawdbot. Installing it was surprisingly simple — a few commands, some configuration files, and it was alive. But then came the hard part: deciding how much of myself to give it.</p><p>Because that’s really what we’re talking about here. Not just installing software, but inviting something into the most intimate spaces of our digital lives.</p><p>I started small. “Pull up that contract from last week and extract all the important dates.”</p><p>It did.</p><p>“Run the tests on this project and fix any errors you find.”</p><p>It did that too — opening my editor, running commands, modifying code, testing again.</p><p>“Write my weekly report and schedule it to send on Monday morning.”</p><p>Within minutes, it had created scripts, configured automation, and completed the entire workflow.</p><p>Each task alone wasn’t miraculous. We’ve had automation tools for years. But watching them flow together, orchestrated by nothing more than conversational English? That felt like witnessing the future arrive early.</p><p>I found myself testing it more boldly. Could it modify my router settings? Yes. Set up a file sync service? Done. Reorganize an entire project folder? Of course.</p><p>By Sunday evening, I was lying on my couch, TV playing in the background, casually rebuilding a website through chat messages. It was thrilling and unsettling in equal measure.</p><h3>The Mac Mini Phenomenon</h3><p>Here’s where things get interesting — and revealing about human nature.</p><p>People aren’t just installing Clawdbot on their main computers. They’re buying dedicated machines for it. The Mac mini, in particular, has become an unexpected star in this story. Small, quiet, energy-efficient, always-on — it’s the perfect home for an AI assistant that never sleeps.</p><p>But the real reason people are buying separate machines has nothing to do with hardware specs. It’s about trust. Or rather, the lack of it.</p><p>Think about what Clawdbot needs to work properly: complete access to your files, permission to run any command, ability to control your browser, access to your passwords and credentials. It needs the keys to your entire digital kingdom.</p><p>Would you hand all of that to an AI running on the same computer where you keep your family photos, financial records, work documents, and private messages?</p><p>Most people, quite sensibly, said no.</p><p>So they bought a second machine. A contained environment. A sandbox where mistakes won’t cost them everything. Some enthusiasts went overboard — stacking multiple Mac minis, connecting Raspberry Pis, building what looks like a miniature data center on their desks.</p><p>The community eventually settled on more practical advice: an old laptop, a cheap cloud server, anything separate from your real life. Because the power to do everything is also the power to destroy everything.</p><h3>The Beautiful, Terrifying Truth</h3><p>Let me be honest with you: Clawdbot scared me.</p><p>Not in a “this is obviously dangerous” way. In a more subtle, more insidious way. It scared me because it worked <em>too</em> well. Because I could feel myself starting to depend on it. Because the convenience was intoxicating.</p><p>After just two days, I found myself thinking: “Why am I doing this manually when I could just ask Clawdbot?”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xsmcUOGhynwnl44uszq0Ug.png" /></figure><p>That’s when I realized the real danger isn’t technical — it’s psychological.</p><p>Clawdbot can misunderstand instructions. It can be confused by ambiguous prompts. It can be tricked by malicious web content. And when it makes mistakes, it doesn’t just give you a wrong answer — it takes wrong actions.</p><p>One user reported that Clawdbot accidentally deleted all their important photos. Another discovered it had leaked sensitive passwords while trying to configure a service. These aren’t theoretical risks — they’re real outcomes from real people trying to use this tool.</p><p>The more context you give it, the smarter it becomes — but also the more of your private information it holds. The more powerful tools you grant it, the more useful it is — but also the more damage it can cause. The more you connect it to the internet, the more workflows it can complete — but also the more vulnerable it becomes to manipulation.</p><p>This is the fundamental paradox of personal AI: the things that make it powerful are the exact same things that make it dangerous.</p><h3>Why I’m Writing This</h3><p>If you’ve been seeing Clawdbot trending, feeling that familiar anxiety of “am I missing out on something important?” — let me offer you some peace of mind.</p><p>You’re not missing out. Not really.</p><p>Clawdbot is remarkable, yes. It’s a glimpse of the future, absolutely. But right now, today, it’s a tool for tinkerers, experimenters, and people willing to accept significant risks for the thrill of playing with cutting-edge technology.</p><p>It’s not ready for your primary computer. It’s not ready for your work machine. It’s not ready for any system containing data you can’t afford to lose.</p><p>The community knows this. That’s why their forums are filled with warnings: “Use dedicated machines.” “Grant minimum permissions.” “Require confirmation for sensitive operations.” “Use temporary credentials.” These aren’t suggestions — they’re essential survival tactics.</p><h3>The Pattern We’ve Seen Before</h3><p>This feels familiar because we’ve been here before.</p><p>Last year around this time, another AI agent called Manus exploded onto the scene. Viral demo videos, breathless narratives about “handing my entire job to AI,” sudden proliferation of tutorials and Discord servers. The hype cycle in full swing.</p><p>But Clawdbot is different in important ways.</p><p>Manus lived in the cloud, safely contained by the platform. Clawdbot lives on your machine, with access to everything you have.</p><p>Manus remembered your conversations. Clawdbot remembers your files, your system configurations, your entire digital environment.</p><p>Manus could only do what the platform allowed. Clawdbot can do anything <em>you</em> can do — and sometimes more.</p><p>Manus was a product you used occasionally. Clawdbot is a presence that runs continuously, always watching, always ready.</p><p>That’s why Clawdbot feels both more magical and more dangerous than anything that came before. It’s not just closer to useful — it’s closer to <em>you</em>. Maybe too close.</p><h3>What This Means for Tomorrow</h3><p>I keep thinking about what Clawdbot represents beyond its current implementation.</p><p>We’re watching personal AI evolve from answering questions to executing tasks. From occasional tool to continuous companion. From application to infrastructure.</p><p>Your computer might soon feel less like a device and more like a home server — always on, always listening, always ready to wake up when you send it a message from across the world. The interface between you and your digital life might become nothing more than a chat window.</p><p>This transformation is coming whether we’re ready or not. The question isn’t <em>if</em> we’ll have AI assistants with system-level access to our devices. The question is <em>when</em>, and more importantly, <em>how</em>.</p><h3>My Advice: Wait, But Watch</h3><p>Here’s what I learned from my weekend with Clawdbot:</p><p>If you’re looking for a polished product that will immediately boost your productivity, you’ll be disappointed. The setup is complex, the permissions are anxiety-inducing, the AI model calls are expensive, and the potential for costly mistakes is very real.</p><p>But if you’re curious about where we’re headed — if you want to understand what personal computing might look like in five years — then Clawdbot is worth studying. Not necessarily using, but observing.</p><p>Right now, it’s a capable but unpredictable creature. Like its lobster mascot, it can do impressive work, but it’s best kept in a controlled environment where you’re willing to accept the consequences of its mistakes.</p><p>The good news? This will get better. The installation process will become smoother. The permission models will mature. Security measures will become standard. Best practices will crystallize into clear guidelines. And when that happens — when Clawdbot or something like it transforms from a geek experiment into a consumer product — then maybe it will be time for the rest of us to dive in.</p><p>Until then, you can rest easy. You haven’t missed anything you truly need.</p><p>But you have glimpsed something extraordinary: a future where the boundary between human intention and machine action becomes almost invisible. Where thinking something and having it done are separated by nothing more than a casual message.</p><p>That future is coming. But it doesn’t have to arrive this weekend.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f11ed52717c9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Scaling PostgreSQL for Multi-Tenant SaaS: A Practical and Beginner-Friendly Guide Using Citus]]></title>
            <link>https://medium.com/@parvemayur/scaling-postgresql-for-multi-tenant-saas-a-practical-and-beginner-friendly-guide-using-citus-ec89fbf3c177?source=rss-6cd41a5da5ef------2</link>
            <guid isPermaLink="false">https://medium.com/p/ec89fbf3c177</guid>
            <category><![CDATA[postgresql-multi-tenant]]></category>
            <category><![CDATA[sharding-postgresql]]></category>
            <category><![CDATA[postgresql-at-scale]]></category>
            <category><![CDATA[scaling-saas-with-citus]]></category>
            <category><![CDATA[scalable-multi-tenant-db]]></category>
            <dc:creator><![CDATA[Mayur Parve]]></dc:creator>
            <pubDate>Sun, 06 Jul 2025 04:35:58 GMT</pubDate>
            <atom:updated>2025-07-06T04:35:58.701Z</atom:updated>
            <content:encoded><![CDATA[<p>PostgreSQL is a highly reliable and feature-rich open-source database, trusted by companies large and small. But as your SaaS product grows to serve thousands — or even millions — of customers (tenants), PostgreSQL on its own can start to feel strained.</p><p>In this guide, we’ll explore how to scale PostgreSQL for large-scale multi-tenant applications using Citus — a powerful extension that transforms PostgreSQL into a distributed database. Whether you’re just starting to think about multi-tenancy or already facing performance bottlenecks, this article will walk you through practical solutions step-by-step.</p><h3>📦 What Is Multi-Tenancy?</h3><p>Multi-tenancy is a software architecture pattern where a single instance of a system serves multiple customers (tenants). Each tenant’s data is kept isolated, but all tenants share the same application codebase and (usually) the same database.</p><h3>Common Multi-Tenant Models</h3><p>ModelDescriptionChallenges at ScaleDatabase per tenantEach customer has their own databaseHard to manage backups, updates, and costSchema per tenantShared DB, but each tenant gets a schemaDifficult to maintain with 1000+ tenantsShared schemaAll tenants share tables, separated by tenant_idBest for scale, but requires careful design</p><p>For scalability, most teams settle on the shared schema approach — where all tenant data lives in the same table and is separated by a tenant_id column.</p><h3>🧱 The Scaling Problem</h3><p>As your SaaS app grows, so does your data. In a shared schema, one table might store billions of rows for hundreds of thousands of tenants.</p><p>At this scale, traditional PostgreSQL starts to show limitations:</p><ul><li>Slow queries due to large table size</li><li>Index bloat and high maintenance cost</li><li>Difficulty in ensuring tenant-level isolation</li><li>Long VACUUM and ANALYZE operations</li><li>Poor performance with native partitioning when tenant count is very high</li></ul><p>Clearly, you need something more powerful.</p><h3>🔧 Why Not Use PostgreSQL’s Built-in Partitioning?</h3><p>PostgreSQL supports table partitioning via LIST, RANGE, and HASH strategies.</p><p>But here’s the catch:</p><ul><li>LIST partitioning by tenant_id doesn’t scale beyond a few thousand tenants.</li><li>RANGE partitioning is best suited for time-series data, not tenant IDs.</li><li>HASH partitioning works — but only within a single server, and offers no distributed capabilities.</li></ul><p>Once your tenant base grows into the hundreds of thousands or more, PostgreSQL’s native partitioning is no longer enough. You need a way to spread the load across machines.</p><h3>🌐 Meet Citus: PostgreSQL at Scale</h3><p>Citus is an open-source PostgreSQL extension that adds distributed capabilities to PostgreSQL. Developed by Citus Data (now part of Microsoft), it transforms a single PostgreSQL instance into a distributed cluster.</p><h3>Key Features of Citus:</h3><ul><li>Turns a regular PostgreSQL table into a distributed one</li><li>Splits tables into smaller pieces called shards</li><li>Distributes shards across multiple nodes (worker nodes)</li><li>Runs queries in parallel across those nodes</li><li>Retains full compatibility with PostgreSQL tools and SQL</li></ul><p>In short: Citus makes PostgreSQL scale horizontally while keeping the features you love.</p><h3>🧠 How Sharding with Citus Works</h3><p>Citus uses a concept called a distribution column — typically tenant_id in multi-tenant systems.</p><p>When you create a distributed table, Citus:</p><ol><li>Hashes the distribution column (e.g., tenant_id)</li><li>Assigns rows to specific shards based on that hash</li><li>Stores those shards across multiple worker nodes</li><li>Automatically routes and parallelizes queries</li></ol><h3>Example:</h3><pre>-- Create a shared table for records<br>CREATE TABLE records (<br>  id BIGSERIAL PRIMARY KEY,<br>  tenant_id BIGINT NOT NULL,<br>  title TEXT,<br>  status TEXT,<br>  created_at TIMESTAMP DEFAULT now(),<br>  metadata JSONB<br>);<br><br>-- Convert the table to a distributed one<br>SELECT create_distributed_table(&#39;records&#39;, &#39;tenant_id&#39;);</pre><p>That’s it! Now your records table is distributed across shards and nodes.</p><h3>🧩 Schema Design for Scalability</h3><p>Let’s look at best practices for schema design in a Citus-powered, shared-schema architecture:</p><ul><li>Always include tenant_id as a required column</li><li>Avoid joins across tenants</li><li>Use JSONB to allow per-tenant custom fields or metadata</li><li>Keep row sizes small and normalized if possible</li><li>Distribute related tables (e.g., users, projects) by tenant_id too</li></ul><p>Example of a scalable tasks table:</p><pre>CREATE TABLE tasks (<br>  id BIGSERIAL PRIMARY KEY,<br>  tenant_id BIGINT NOT NULL,<br>  title TEXT NOT NULL,<br>  status TEXT NOT NULL,<br>  due_date DATE,<br>  metadata JSONB,<br>  created_at TIMESTAMP DEFAULT now()<br>);</pre><p>Distribute it:</p><pre>SELECT create_distributed_table(&#39;tasks&#39;, &#39;tenant_id&#39;);</pre><h3>⚙️ Optimizing Queries</h3><p>To ensure good performance in a distributed setup, follow these practices:</p><p>✅ Always include tenant_id in WHERE clauses.</p><p>✅ Create indexes that include tenant_id.</p><p>❌ Avoid queries that span across tenants (like global SELECT *).</p><h3>Good:</h3><pre>SELECT * FROM tasks<br>WHERE tenant_id = 56789 AND status = &#39;open&#39;;</pre><h3>Bad:</h3><pre>SELECT * FROM tasks WHERE status = &#39;open&#39;; -- Will scan all shards</pre><h3>Suggested Indexes:</h3><pre>CREATE INDEX ON tasks (tenant_id, status);<br>CREATE INDEX ON tasks ((metadata-&gt;&gt;&#39;priority&#39;));</pre><p>These help speed up filtered queries while still maintaining tenant isolation.</p><h3>🛠 Operational Benefits of Using Citus</h3><p>FeatureBenefitAutomatic shardingScale tables horizontally with easeParallel queriesImprove query performance dramaticallyNode rebalancingMove shards across nodes as neededCloud-readyCitus is available on Azure &amp; open sourcePostgreSQL compatibilityUse existing tools, extensions, and SQL</p><p>You can scale out reads and writes simply by adding more worker nodes.</p><h3>🔐 Security and Isolation</h3><ul><li>Ensure that every query in your app filters by tenant_id</li><li>Optionally enforce tenant isolation with Row-Level Security (RLS)</li><li>Limit cross-tenant access in your business logic layer</li></ul><p>Tip: RLS + parameterized queries help avoid accidental data leaks.</p><h3>⚠️ Common Pitfalls to Avoid</h3><p>MistakeWhy it’s a problemQueries without tenant_idCause full cluster scans and slow performanceJoins between distributed and local tablesCan break query routing and affect speedUsing LIST partitions for each tenantDoesn’t scale beyond thousands of partitionsForgetting to shard related tablesCan lead to cross-node joins and errors</p><p>—</p><h3>✅ When Should You Use Citus?</h3><p>You should strongly consider Citus when:</p><ul><li>You expect your tenant count to grow past 10,000</li><li>You anticipate billions of rows of data</li><li>You want to retain PostgreSQL’s power but scale horizontally</li><li>You need better performance than native PostgreSQL can provide</li></ul><p>Citus helps you scale incrementally without moving away from your PostgreSQL roots.</p><h3>🧾 Final Thoughts</h3><p>PostgreSQL is powerful — but like any single-node system, it has its limits. By combining PostgreSQL with Citus, you unlock the ability to scale your application to millions of tenants and billions of rows — all while staying within the ecosystem you already know.</p><p>With proper schema design, distribution by tenant_id, and good query hygiene, Citus makes it easy to scale your SaaS backend for the long term.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ec89fbf3c177" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>