DEV Community: Ramu Narasinga

warden.toml in Openwork codebase.

Ramu Narasinga — Wed, 12 Aug 2026 15:30:00 +0000

In this article, we review warden.toml in Openwork codebase. You will learn:

What is Warden?
Warden.toml file

What is Warden?

Warden watches over your code by running skills against your changes. Skills are Markdown prompts that define what to look for: security vulnerabilities, correctness bugs, API contract issues, performance problems, or anything else that needs consistent review coverage.

The important split:

warden.toml- Which skills run, which files they see, and how findings are reported.
GitHub workflow - When GitHub starts Warden and which credentials/action inputs are available.
Skill files - The review expertise Warden applies to changed code.

Every analysis run follows the same loop:

Identify what changed: files, hunks, directories, or an explicit git range.
Match changes against configured triggers.
Run the matching skills against the matching code.
Report findings with severity, location, and optional fixes.

Skills follow the agentskills.io specification. Warden includes security-review for baseline AppSec coverage and code-review for correctness bugs. Treat them as first passes, then add more skills when your codebase needs deeper coverage.

Learn more about Warden

Warden.toml file

We just found in the docs what this warden.toml file is about. It defines

Which skills to run?
Which files they see?
How findings are reported?

Openwork's warden.toml file

Below is the code i picked from openwork/warden.toml file

version = 1

# Warden gates clearance on blocking findings from two skills:
# diff-security-review (all findings block) and desktop-den-sync-review (only
# high findings block; medium findings are advisory). The clearance itself is
# granted by .github/workflows/warden-clearance.yml.

[defaults]
reportOn = "low"
ignorePaths = [
  "**/node_modules/**",
  "**/pnpm-lock.yaml",
  "**/dist/**",
  "**/*.min.js",
]

[defaults.agent]
model = "openai/gpt-5.6-luna"

# Auxiliary verifies/merges findings and gates what survives to the report;
# keep it on the same strong model so weak verification can't cause a false
# clearance.
[defaults.auxiliary]
model = "openai/gpt-5.6-luna"

[[skills]]
name = "diff-security-review"

[[skills.triggers]]
type = "pull_request"
actions = ["opened", "synchronize", "reopened"]
draft = false

# Lets developers run `warden` locally on uncommitted changes before pushing.
[[skills.triggers]]
type = "local"

[[skills]]
name = "desktop-den-sync-review"
paths = [
  "apps/app/**",
  "apps/desktop/**",
  "ee/apps/den-api/**",
  "packages/types/**",
]

[[skills.triggers]]
type = "pull_request"
actions = ["opened", "synchronize", "reopened"]
draft = false

[[skills.triggers]]
type = "local"

Warden can be run in Github Actions context and you can find how Openwork defined their warden configuration at openwork/.github/warden.yaml

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

I spent 3+ years studying OSS codebases and wrote 400+ articles on what makes the production-grade. Now I'm putting that into practice differently - instead of writing every fix myself, I run coding agents that do it.

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

openwork, the open-source alternative to Claude Cowork.

Ramu Narasinga — Tue, 11 Aug 2026 15:30:00 +0000

In this article, we review Openwork. You will learn:

What is Openwork?
Features

What is Openwork?

OpenWork is a free, open-source desktop app made for sharing AI workflows. It is an open-source alternative to Claude Cowork and Codex for macOS, Windows, and Linux.

Add one OpenWork MCP to Codex, Claude Code, Cursor, or another compatible agent and reuse the same skills, MCPs, and connected services across your tools, teammates, and machines. Create something once, share it with coworkers or friends, or keep it for yourself.

The desktop app is there when you want a dedicated workspace, but it is not required. You can use OpenWork from the agent you already have. For larger organizations, the admin interface lets you publish capabilities, manage access, and configure shared or per-user connections.

You can download Openwork here

Features

Chat on your files and tools
Claude and models
GPT-5, Gemini, Mistral, and local models
Browser automation
MCP gateway

and much more

I checked the docs for the browser automation and these are my findings:

How to use OpenWork to automate the built-in browser?

Computer-use in OpenWork currently works through the built-in OpenWork Browser. It does not yet mean full desktop control of Ubuntu, macOS, or Windows apps.OpenWork can open pages, click, fill forms, read page content, and take screenshots inside that browser. If you connect to a remote OpenWork server, the browser runs on that remote worker.Today, the supported path is the first-party OpenWork Browser extension.

Learn more about Browser Automation.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Voicebox, the open-source AI voice studio.

Ramu Narasinga — Mon, 10 Aug 2026 15:30:00 +0000

In this article, we review Voicebox. You will learn:

What is Voicebox?

What is Voicebox?

I found the Voicebox trending this week on Github. I got the below definition from their README.

Voicebox is a local-first AI voice studio - a free and open-source alternative to ElevenLabs and WisprFlow in one app. Clone voices from a few seconds of audio, generate speech in 23 languages across 7 TTS engines, dictate into any text field with a global hotkey, and give any MCP-aware AI agent a voice of your choosing.

The two cloud incumbents sit on opposite halves of the voice I/O loop - ElevenLabs on output, WisprFlow on input. Voicebox does both, bridges them with a bundled local LLM for refinement and per-profile personas, and runs the whole thing on your machine.

Complete privacy - models, voice data, and captures never leave your machine
7 TTS engines - Qwen3-TTS, Qwen CustomVoice, LuxTTS, Chatterbox Multilingual, Chatterbox Turbo, HumeAI TADA, and Kokoro
Voice cloning and preset voices - zero-shot cloning from a reference sample, or 50+ curated preset voices via Kokoro and Qwen CustomVoice
23 languages - from English to Arabic, Japanese, Hindi, Swahili, and more
Post-processing effects - pitch shift, reverb, delay, chorus, compression, and filters
Expressive speech - paralinguistic tags like [laugh], [sigh], [gasp] via Chatterbox Turbo; natural-language delivery control via Qwen CustomVoice
Unlimited length - auto-chunking with crossfade for scripts, articles, and chapters
Stories editor - multi-track timeline for conversations, podcasts, and narratives
Voice input - global dictation hotkey with push-to-talk and toggle modes, accessibility-verified auto-paste on macOS, in-app mic on every text field, Whisper-based STT
Agent voice output - one tool call (voicebox.speak) and any MCP-aware agent (Claude Code, Cursor, Cline) speaks to you in a voice you've cloned
Voice personalities - attach a free-form persona to any voice profile, then Compose, Rewrite, or Respond via a bundled local LLM - agents can invoke the same modes over MCP
API-first - REST API plus a built-in MCP server for integrating voice I/O into your own apps and agents
Native performance - built with Tauri (Rust), not Electron
Runs everywhere - macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, Docker

Features

Multi-Engine Voice Cloning
Emotion and Paralinguistic Tags
Post-Processing Effects
Unlimited Generation Length
Generation versions
Async Generation Queue
Voice Profile Management
Stories Editor
Global Dictation and Voice Input
Speech-to-text

I recommend to checkout Voicebox README, to get a comprehensive list of features supported.

API

The following API examples were provided in the README.

# Generate speech
curl -X POST http://127.0.0.1:17493/generate \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello world", "profile_id": "abc123", "language": "en"}'

# Agent voice output - any app or script can speak in a cloned voice
curl -X POST http://127.0.0.1:17493/speak \
  -H "Content-Type: application/json" \
  -H "X-Voicebox-Client-Id: my-script" \
  -d '{"text": "Deploy complete.", "profile": "Morgan"}'

# Transcribe an audio file
curl -X POST http://127.0.0.1:17493/transcribe \
  -F "audio=@recording.wav" \
  -F "model=whisper-turbo"

# List voice profiles
curl http://127.0.0.1:17493/profiles

Is it free? yes, atm. Voicebox mentioned cloud based pricing is coming soon, at the time of writing this article.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

TencentDB Agent Memory, a team-level memory hub for AI Agents.

Ramu Narasinga — Mon, 03 Aug 2026 15:30:00 +0000

In this article, we review TencentDB Agent Memory. You will learn:

What is TencentDB Agent Memory?
How is Agent Memory implemented?

What is TencentDB Agent Memory?

TencentDB Agent Memory authors started from a practical question: How do you reduce repetitive work when using Agents?

If project context has already been explained, it shouldn't need to be repeated in a new session. If documents have already been read, every Agent shouldn't have to start again from page one. A workflow that already works shouldn't have to be rediscovered next time.

Memory here means more than just "remembering conversations." Any information that helps the next Agent avoid reinventing the wheel should be saved, organized, and reused.

Existing information → Reusable memory assets → Fewer turns → Less rework → More stable results and higher efficiency

I recommend reading these sections from the Github README:

How is Agent Memory implemented?

I found this technical implementation in the README.. TencentDB Agent Memory doesn't aim to "store everything." It solves three problems: what's worth keeping, who can use it, and how to retrieve less while retrieving the right things next time.

These below sections are defined:

Memory isn't flat records - it grows in layers

Memory isn't a global prompt - it's the Agent's loadout
Knowledge isn't injected wholesale - it's called on demand

Benchmarking is done using Personamem. Learn more about PersonaMem

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Alchemy, an Infrastructure-as-Effects framework.

Ramu Narasinga — Tue, 28 Jul 2026 15:30:00 +0000

In this article, we review Alchemy. You will learn:

What is Alchemy?
alchemy.run.ts file in OSS projects.

What is Alchemy?

Well, before we jump into its definition, let me explain how I found in the open source projects. I came across the file named alchemy.run.ts in t3code.. This got me google Alchemy and found this site — https://alchemy.run/.

Alchemy is an Infrastructure-as-Effects framework. It extends Infrastructure-as-Code by combining your cloud resources and the application logic that uses them into a single, type-safe program powered by Effects.

Learn more about Alchemy.

Quick start guide:

Create a project

mkdir my-app && cd my-app && bun init -y

Install dependencies

bun add "alchemy@next" "effect@>=4.0.0-beta.100 || >=4.0.0" "@effect/platform-bun@>=4.0.0-beta.100 || >=4.0.0" "@effect/platform-node@>=4.0.0-beta.100 || >=4.0.0"

Create your stack — in the file, alchemy.run.ts

import * as Alchemy from "alchemy";
import * as Cloudflare from "alchemy/Cloudflare";
import * as Effect from "effect/Effect";

export default Alchemy.Stack(
  "MyApp",
  {
    providers: Cloudflare.providers(),
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const bucket = yield* Cloudflare.R2.Bucket("Bucket");

    return {
      bucketName: bucket.bucketName,
    };
  }),
);

Deploy — Run alchemy deploy to create the Bucket on Cloudflare

I got these instructions from the Getting Started docs.

alchemy.run.ts file in OSS projects.

You define your stack in alchemy.run.ts, you have to remember this from the Getting Started guide.

t3code/infra/relay/alchemy.run.ts

You will find the below code in t3code/infra/../alchemy.run.ts

// @effect-diagnostics anyUnknownInErrorContext:off layerMergeAllWithDependencies:off - Alchemy provider helpers expose framework-owned any requirements.
import * as Alchemy from "alchemy";
import * as Axiom from "alchemy/Axiom";
import * as Cloudflare from "alchemy/Cloudflare";
import * as Drizzle from "alchemy/Drizzle";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Planetscale from "alchemy/Planetscale";

import * as RelayDb from "./src/db.ts";
import { RelayObservability } from "./src/observability.ts";
import { ManagedEndpointZone, RelayApiZone } from "./src/zone.ts";
import ApiLive, { Api } from "./src/worker.ts";

export default Alchemy.Stack(
  "T3CodeRelay",
  {
    providers: Layer.mergeAll(
      Axiom.providers(),
      Cloudflare.providers(),
      Drizzle.providers(),
      Planetscale.providers(),
    ),
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const db = yield* RelayDb.PlanetscaleDatabase;
    const hyperdrive = yield* RelayDb.RelayHyperdrive;
    const managedEndpointZone = yield* ManagedEndpointZone.pipe(Effect.orDie);
    const relayApiZone = yield* RelayApiZone.pipe(Effect.orDie);
    const observability = yield* RelayObservability;
    const api = yield* Api;

    return {
      databaseName: db.database.name,
      databaseBranchName: db.branch?.name ?? "main",
      hyperdriveName: hyperdrive.name,
      workerName: api.workerName,
      url: api.url,
      relayApiZoneId: relayApiZone.zoneId,
      managedEndpointZoneId: managedEndpointZone.zoneId,
      mobileTracingUrl: observability.traces.otelTracesEndpoint,
      mobileTracingDataset: observability.traces.name,
      mobileTracingToken: observability.mobileIngestToken.token,
      clientTracingUrl: observability.traces.otelTracesEndpoint,
      clientTracingDataset: observability.traces.name,
      clientTracingToken: observability.clientIngestToken.token,
    };
  }).pipe(Effect.provide(ApiLive)),
);

open-seo/alchemy.run.ts

This open-seo/alchemy.run.ts has about 310 LOC at the time of writing this article. Below I copied the important code snippet:

export default Alchemy.Stack(
  "open-seo",
  {
    providers: Cloudflare.providers(),
    // Durable state in the Cloudflare state store (an `alchemy-state-store`
    // Worker on this account; one-time `pnpm alchemy cloudflare bootstrap`).
    // CI fetches its auth token from the account Secrets Store each run.
    state: Cloudflare.state(),
  },
  Effect.gen(function* () {
    const stage = yield* Alchemy.Stage;
    const prod = stage === HOSTED_PROD_STAGE;
    // Fail closed: an unset AUTH_MODE gets the Access-gated mode (matching the
    // app's own default in src/lib/auth-mode.ts), never public hosted signup.
    // hosted/local_noauth must be set explicitly.
    const authMode = yield* Config.string("AUTH_MODE").pipe(
      Config.withDefault("cloudflare_access"),
    );
    const databaseProvider = yield* optionalVar("DATABASE_PROVIDER");
    const workersSubdomain = yield* readWorkersSubdomain({ required: false });

    // Auth needs an absolute BETTER_AUTH_URL. Prod sets it explicitly;
    // previews always derive it from the deterministic worker name — a wrong
    // WORKERS_SUBDOMAIN surfaces in CI's post-deploy Access verify step.
    let authUrl: string;
    if (prod) {
      authUrl = yield* optionalVar("BETTER_AUTH_URL");
      if (!authUrl) {
        return yield* Effect.die(
          new Error(
            "Set BETTER_AUTH_URL (https://app.openseo.so) in .env.production.",
          ),
        );
      }
      // Prod must say which database it runs on. A silently-defaulted "d1"
      // would deploy cleanly against the stale pre-Postgres data.
      if (databaseProvider !== "postgres" && databaseProvider !== "d1") {
        return yield* Effect.die(
          new Error(
            "Set DATABASE_PROVIDER explicitly in .env.production (prod runs postgres).",
          ),
        );
      }
    } else if (workersSubdomain) {
      authUrl = `https://${workerName(stage)}.${workersSubdomain}`;
    } else if (authMode === "hosted") {
      return yield* Effect.die(
        new Error(
          "Hosted previews derive BETTER_AUTH_URL from WORKERS_SUBDOMAIN — set it to the account's full workers.dev subdomain (shown under Workers & Pages).",
        ),
      );
    } else {
      // local_noauth / cloudflare_access never read BETTER_AUTH_URL —
      // src/lib/auth.ts uses a placeholder baseURL off the hosted path.
      authUrl = "";
    }

    // cloudflare_access self-host reads these; hosted/local_noauth leave them
    // empty. (Deriving/provisioning the Access application is a follow-up PR.)
    const teamDomain = yield* optionalVar("TEAM_DOMAIN");
    const policyAud = yield* optionalVar("POLICY_AUD");

    const app = yield* Cloudflare.Worker("open-seo", {
      name: workerName(stage),
      // Prod serves the real domains; the zone is inferred from the hostname.
      domain: prod ? ["app.openseo.so", "www.app.openseo.so"] : undefined,
      // Prebuilt worker from `vite build` (@cloudflare/vite-plugin). The entry
      // exports the DO + WorkflowEntrypoint classes (re-exported by
      // src/server.ts), which `bundle: false` requires. Sibling chunks under
      // assets/ are uploaded as-is by the default module rules.
      main: "./dist/server/index.js",
      bundle: false,
      assets: {
        directory: "./dist/client",
      },
      compatibility: {
        date: wrangler.compatibility_date,
        flags: wrangler.compatibility_flags,
      },
      // Site audits parse and persist batches of HTML inside Workflow steps.
      // Paid Workers permit up to five minutes; keep headroom for unusually
      // link-heavy sites after bounding page bodies and bulk-writing links.
      limits: { cpuMs: 300_000 },
      observability: {
        enabled: wrangler.observability?.enabled ?? true,
        traces: { enabled: wrangler.observability?.traces?.enabled ?? false },
      },
      placement:
        wrangler.placement?.mode === "smart" ? { mode: "smart" } : undefined,
      // Scheduled rank checks — src/server.ts `scheduled` handler.
      crons: wrangler.triggers.crons,
      env: {
        ...makeResources(stage),
        ...dataEnv,
        AUTH_MODE: authMode,
        DATABASE_PROVIDER: databaseProvider || "d1",
        BETTER_AUTH_URL: authUrl,
        TEAM_DOMAIN: teamDomain,
        POLICY_AUD: policyAud,

        // Prod-only: pooled Postgres via the existing Hyperdrive config.
        ...(prod ? { HYPERDRIVE: makeHyperdrive() } : {}),

        // Durable Objects (Agents SDK chat agents). Alchemy backs new DO
        // classes with SQLite storage, which both require.
        ...Object.fromEntries(
          wrangler.durable_objects.bindings.map((binding) => [
            binding.name,
            Cloudflare.DurableObject(binding.name, {
              className: binding.class_name,
            }),
          ]),
        ),

        // Cloudflare Workflows (upstream props-only form for prebuilt
        // workers). Workflow names are ACCOUNT-scoped: prod owns the
        // unsuffixed names; previews carry the stage suffix so concurrent
        // stages can't repoint each other's workflows (registration is a
        // PUT-as-upsert on the name).
        ...Object.fromEntries(
          wrangler.workflows.map((workflow) => [
            workflow.binding,
            Cloudflare.Workflow(
              prod ? workflow.name : `${workflow.name}-${stage}`,
              { className: workflow.class_name },
            ),
          ]),
        ),
      },
    }).pipe(
      // Prod adopts the live worker serving app.openseo.so; never delete it
      // on destroy. (Workflow registrations aren't individually retainable —
      // they're created inside the worker provider — but re-registering them
      // is a lossless upsert, unlike deleting the data-bearing resources.)
      Alchemy.RemovalPolicy.retain(prod),
    );

    return { url: app.url.as<string>() };
  }),

Tbh, I do not completely understand this stack setup using Cloudflare. Doing some simple project deployments on cloudflare should help you understand the concepts better.

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Browser Use, Make websites accessible for AI agents.

Ramu Narasinga — Fri, 10 Jul 2026 15:30:00 +0000

In this article, we review Browser Use. You will learn:

What is Browser Use
Quickstart guide

What is Browser Use

Browser Use is a Python library for AI browser automation with 104k+ GitHub stars. Connect any LLM and run locally or self-hosted.

I came across the Browser Use when I was checking out the Page Agent.

When you sign up on Browser Use, you will see the above screen. To give it a shot, since a new user get 10 free tasks, I wrote the following prompt and submitted:

Find the cheapest flight from London to Vancouver

It ran for some time and gave this result.

You will find two tabs on the right:

Browser
Files

The one I opened is an output produced at the end of the conversation. But this is just one example.

Use cases

I found more examples in their Github README such as:

Open those links, you will find demo videos, demonstrating how powerful browser use is.

Quickstart guide

If you want to use Browser Use in your agent (Claude Code, Codex, Cursor, Hermes, OpenClaw, etc.), paste this prompt, and it sets everything up itself:

Install or upgrade browser-use to the latest stable version with uv using Python 3.12, run `browser-use skill install` to register the skill, and connect it to my browser. If setup or connection fails, follow https://github.com/browser-use/browser-harness/blob/main/install.md.

Then tell your agent what you want done.

Python library: the easiest way to automate the web

Want to automate the web at scale, from your own code, and with any LLM? Use the Python library:

Install Browser Use (Python >= 3.11):

uv add browser-use
# or: pip install browser-use

Add your LLM API key to .env. Get one from Browser Use Cloud, or bring your own provider key:

# .env
BROWSER_USE_API_KEY=your-key
# GOOGLE_API_KEY=your-key
# ANTHROPIC_API_KEY=your-key

Run your first agent:

import asyncio

from browser_use import Agent, ChatBrowserUse

async def main():
    agent = Agent(
        task="Find the number of stars of the browser-use repo",
        llm=ChatBrowserUse(model='openai/gpt-5.5'),
        # llm=ChatBrowserUse(model='bu-2-0'),  # Browser Use's optimized model
        # llm=ChatOpenAI(model='gpt-5.5'),
        # llm=ChatAnthropic(model='claude-opus-4-8'),  # Sonnet also works well
    )
    history = await agent.run()

if __name__ == "__main__":
    asyncio.run(main())

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works? Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Page Agent, the GUI Agent Living in Your Webpage.

Ramu Narasinga — Tue, 07 Jul 2026 16:00:00 +0000

In this article, we review Page Agent. You will learn:

What is Page Agent?
Setup
Usecase

What is Page Agent?

Page Agent is the GUI Agent Living in Your Webpage. One script gives any web page its own AI agent.

This repo is from Alibaba organization.

Features

🎯 Easy integration

No need for browser extension / python / headless browser.
Just in-page javascript. Everything happens in your web page.

📖 Text-based DOM manipulation

No screenshots. No multi-modal LLMs or special permissions needed.

🧠 Bring your own LLMs

Works with most mainstream models, including locally deployed ones. See supported models

🐙 Optional chrome extentions for multi-page tasks.

And an MCP Server (Beta) to control it from outside.

Setup

Fastest way to try PageAgent with their free Demo LLM:

<script
    src="https://cdn.jsdelivr.net/npm/page-agent@1.11.0/dist/iife/page-agent.demo.js"
    crossorigin="anonymous"
></script>

Add ?autoInit=false to load the script without creating the demo agent automatically. You can then instantiate it with new window.PageAgent(...).

Usecases

SaaS AI Copilot - Ship an AI copilot in your product in lines of code. No backend rewrite.
Smart Form Filling - Turn 20-click workflows into one sentence. Perfect for ERP, CRM, and admin systems.
Accessibility - Make any web app accessible through natural language. Voice commands, screen readers, zero barrier.
Multi-page Agent - Extend your own web agent's reach across browser tabs via the Chrome extentions
MCP - Allow your agent clients to control your browser.

I copied this above info from Page Agent Readme

I am curious if its possible to generate test cases and hand it over to page agent to do its thing and verify the UI works as expected. I will try this in my product thinkthroo.com

About me:

Hey, my name is Ramu Narasinga. Email: ramu.narasinga@gmail.com

How it works?
Register your machine as a Runtime, point it at your repo. Agents pick up issues. write the fix, open the PR. You just review, they execute.

Build your coding agents and get more work done in less time at thinkthroo.com

References:

Caveman, a Claude Code skill that cut 65% of tokens.

Ramu Narasinga — Tue, 07 Jul 2026 15:30:00 +0000

In this article, we review Caveman. You will learn:

What is Caveman?
Setup

What is Caveman?

Caveman is a skill/plugin for Claude code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, and 30+ other agents. Install once. Agent drops the filler and answers in tight caveman-speak, keeping code, commands, and errors byte-for-byte exact. You save output tokens on every reply, forever.

Above is a screenshot from the Caveman README file. It demonstrates how the output tokens can be saved by using less words.

Caveman no make brain smaller. Caveman make mouth smaller. Shrinks what the agent says, not what it knows.

Setup

In the install section, I found the below command

# macOS · Linux · WSL · Git Bash
curl -fsSL https://raw.githubusercontent.com/JuliusBrussee/caveman/main/install.sh | bash

When you run this command, caveman finds every agent on your machine and installs for each of them.

okay what happens after you run this command? In the README, it is mentioned as shown below:

Turn it on: type /caveman or say "talk like caveman". Turn it off: say "normal mode". On Claude Code, Codex, and Gemini it's already on from message one. No command needed.

Wait, there is also modes to this:

There is more from Julius Brussee

Learn more about Caveman.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

`acquireLock` function in claude-context codebase.

Ramu Narasinga — Thu, 02 Jul 2026 15:30:00 +0000

In this article, we review acquireLock function in claude-context codebase. You will learn:

What is claude-context?
acquireLock function explained.

What is claude-context?

Make entire codebase the context for any coding agent using claude-context. Claude Context is an MCP plugin that adds semantic code search to Claude Code and other AI coding agents, giving them deep context from your entire codebase.

🧠 Your Entire Codebase as Context: Claude Context uses semantic search to find all relevant code from millions of lines. No multi-round discovery needed. It brings results straight into the Claude’s context.

💰 Cost-Effective for Large Codebases: Instead of loading entire directories into Claude for every request, which can be very expensive, Claude Context efficiently stores your codebase in a vector database and only uses related code in context to keep your costs manageable.

Setup

Use the command line interface to add the Claude Context MCP server:

```plaintextclaude mcp add claude-context \
-e OPENAI_API_KEY=sk-your-openai-api-key \
-e MILVUS_ADDRESS=your-zilliz-cloud-public-endpoint \
-e MILVUS_TOKEN=your-zilliz-cloud-api-key \
-- npx @zilliz/claude-context-mcp@latest




### Why I chose to write about acquireLock?

As I was reading thru the claude-context source code, I came across the concepts like saving snapshot. Saving where? I asked this question and looked into the function implementation.

Below is a code snippet from [handler.ts,](https://github.com/zilliztech/claude-context/blob/master/packages/mcp/src/handlers.ts#L324) showing how the saveCodebaseSnapshot is invoked.



```javascript
// Check if already indexing
if (this.snapshotManager.getIndexingCodebases().includes(absolutePath)) {
    if (forceReindex) {
        console.log(`[FORCE-REINDEX] Clearing stale indexing state for '${absolutePath}'`);
        this.snapshotManager.removeCodebaseCompletely(absolutePath);
        this.snapshotManager.saveCodebaseSnapshot();
    } else {
        return {
            content: [{
                type: "text",
                text: `Codebase '${absolutePath}' is already being indexed in the background. Please wait for completion.`
            }],
            isError: true
        };
    }
}

saveCodebaseSnapshot

Below is the code snippet picked from the snapshot.ts

public saveCodebaseSnapshot(): void {
  console.log('[SNAPSHOT-DEBUG] Saving codebase snapshot to:', this.snapshotFilePath);

  const locked = this.acquireLock();
  if (!locked) {
      console.warn('[SNAPSHOT-DEBUG] Failed to acquire lock, saving without lock');
  }

  try {
      // Ensure directory exists
      const snapshotDir = path.dirname(this.snapshotFilePath);
      if (!fs.existsSync(snapshotDir)) {
          fs.mkdirSync(snapshotDir, { recursive: true });
          console.log('[SNAPSHOT-DEBUG] Created snapshot directory:', snapshotDir);
      }
...

I mean, snapshot is written to your local file system. Claude-Context uses file system to keep track of codebase indexing, is what I figured looking at some of the files and the way file-system was used.

Since we now understand what led to finding this acquireLock function, let’s take a look at this function, acquireLock.

`acquireLock` function explained.

acquireLock is defined in claude-context/packages/mcp/snapshot.ts at L555 as shown below:

private acquireLock(maxRetries = 5, retryInterval = 100): boolean {
    const lockPath = this.snapshotFilePath + '.lock';
    for (let i = 0; i < maxRetries; i++) {
        try {
            fs.mkdirSync(lockPath);
            return true;
        } catch {
            // Check for stale lock (> 10 seconds old)
            try {
                const stat = fs.statSync(lockPath);
                if (Date.now() - stat.mtimeMs > 10000) {
                    fs.rmdirSync(lockPath);
                    continue; // retry after removing stale lock
                }
            } catch { /* lock was removed by another process */ }
            // Busy wait and retry
            const waitUntil = Date.now() + retryInterval;
            while (Date.now() < waitUntil) { /* busy wait */ }
        }
    }
    return false;
}

It creates a lock file using the snapshotFilePath with .lock extension and then returns true. mkdirsync synchronously creates a directory. Returns undefined, or if recursive is true, the first directory path created. This is the synchronous version of mkdir.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Hunk, terminal diffs for humans and agents.

Ramu Narasinga — Wed, 24 Jun 2026 15:30:00 +0000

In this article, we review what a hunk library is. You will learn:

What is Hunk?
Modem

What is Hunk??

Hunk is a review-first terminal diff viewer for agent-authored changesets, built on OpenTUI and Pierre diffs..

Features

multi-file review stream with sidebar navigation
inline AI and agent annotations beside the code
split, stack, and responsive auto layouts
watch mode for auto-reloading file and Git-backed reviews
keyboard, mouse, pager, and Git difftool support

Quick start

hunk           # show help
hunk --version # print the installed version

Working with Git

Hunk mirrors Git’s diff-style commands, but opens the changeset in a review UI instead of plain text.

hunk diff                      # review current repo changes, including untracked files
hunk diff --watch              # auto-reload as the working tree changes
hunk show                      # review the latest commit
hunk show HEAD~1               # review an earlier commit

Working with agents

Open Hunk in another terminal with hunk diff or hunk show.
Tell your agent to add the skill file returned by hunk skill path.
Ask your agent to use the skill against the live Hunk session.

A good generic prompt is:

Load the Hunk skill and use it for this review. Run `hunk skill path` to get the skill path.

Learn more about hunk.dev/..

Modem

Hunk is an opensource library authored by Modem. Modem captures every piece of customer feedback your team gets — from Slack, Linear, GitHub, Intercom, and PostHog — and triages it automatically so engineers spend less time PMing and more time shipping.

Build what’s actually important

Every bug report, every feature request, automatically clustered and prioritized
Unified company & user profiles to understand who matters and who can wait
Spot emerging trends before they become fires

Act on problems you didn’t know you had

Get alerted to user concerns as they happen, not days later
Create detailed tickets automatically or straight from chat
Delegate tasks to coding agents with the context they need to be successful

Learn more about Modem..

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

`undici.setGlobalDispatcher` function in pi-coding-agent package.

Ramu Narasinga — Thu, 18 Jun 2026 15:30:00 +0000

In this article, we review undici.setGlobalDispatcher function in earendil-works/pi/packages/coding-agent. You will learn:

What is pi-coding-agent?
What is Undici?
setGlobalDispatcher method in pi-coding-agent

What is pi-coding-agent?

Pi is a minimal agent harness. Adapt Pi to your workflows, not the other way around. Customize Pi with extensions, skills, prompt templates and themes. Bundle them as Pi packages and share via npm or git.

Pi ships with powerful defaults but skips features like sub-agents and plan mode. Ask Pi to build what you want, or install a package that does it your way.

Four modes: interactive, print/JSON, RPC, and SDK.. See OpenClaw for a real-world integration.

Learn more about pi-coding-agent.

What is Undici?

Undici is a fast, modern HTTP/1.1 and HTTP/2 client written from scratch for Node.js. Maintained by the Node.js core team, it serves as the underlying engine that powers Node's built-in fetch global API.

Why Use the Standalone Package?

While Node.js embeds a version of Undici internally, installing it explicitly from the undici npm page gives you distinct advantages: [ 1, 2. ]

Advanced Features: Access specialized clients like ProxyAgent, Socks5Agent, and MockAgent.
Maximum Performance: Use the low-level undici.request function for faster request handling than standard fetch.
Connection Pooling: Configure and optimize connection limits and keep-alive behaviors manually.
HTTP Pipelining: Enable concurrent request pipelining over a single connection.
Latest Updates: Receive bug fixes, performance updates, and security patches without waiting for a full Node.js runtime upgrade. [ 1, 2, 3, 4, 5. ]

Learn more about Undici

setGlobalDispatcher method in pi-coding-agent

well, to understand why this method used in pi-coding-agent, we need to first check the official docs for this.

undici.setGlobalDispatcher(dispatcher)

Sets the global dispatcher used by Common API Methods. Global dispatcher is shared among compatible undici modules, including undici that is bundled internally with node.js.

Undici stores this dispatcher under Symbol.for('undici.globalDispatcher.2').

setGlobalDispatcher() also mirrors the configured dispatcher to Symbol.for('undici.globalDispatcher.1') using Dispatcher1Wrapper, so Node.js built-in fetch can keep using the legacy handler contract while Undici uses the new handler API.

Below is an example I picked from the Undici module docs

import { request, fetch, Agent, setGlobalDispatcher } from 'undici';

// Use undici.request for maximum performance
const { statusCode, headers, body } = await request('https://api.example.com/data');
const data = await body.json();

// Or use undici.fetch with custom configuration
const agent = new Agent({ keepAliveTimeout: 10000 });
setGlobalDispatcher(agent);
const response = await fetch('https://api.example.com/data');

This way, you can set your custom configuration and dispatch globally so the fetch uses the configuration dispatched. With this info, let's take a closer look at pi-coding-agent's usage.

The below code snippet is picked from pi/packages/coding-agent/src/core/http-dispatcher.ts..

...
export function configureHttpDispatcher(timeoutMs: number = DEFAULT_HTTP_IDLE_TIMEOUT_MS): void {
 const normalizedTimeoutMs = parseHttpIdleTimeoutMs(timeoutMs);
 if (normalizedTimeoutMs === undefined) {
  throw new Error(`Invalid HTTP idle timeout: ${String(timeoutMs)}`);
 }
 undici.setGlobalDispatcher(
  new undici.EnvHttpProxyAgent({
   allowH2: false,
   bodyTimeout: normalizedTimeoutMs,
   headersTimeout: normalizedTimeoutMs,
  }),
 );
 // Keep fetch and the dispatcher on the same undici implementation. Node 26.0's
 // bundled fetch can otherwise consume compressed responses through npm undici's
 // dispatcher without decompressing them, causing response.json() failures.
 // If a caller replaced fetch after module load, preserve that deliberate override.
 const shouldInstallGlobals =
  installedGlobalFetch === undefined
   ? globalThis.fetch === originalGlobalFetch
   : globalThis.fetch === installedGlobalFetch;
 if (shouldInstallGlobals) {
  undici.install?.();
  installedGlobalFetch = globalThis.fetch;
 }
}

Just like what we learnt, there is a custom configuration applied and dispatched:

new undici.EnvHttpProxyAgent({
   allowH2: false,
   bodyTimeout: normalizedTimeoutMs,
   headersTimeout: normalizedTimeoutMs,
}),

and this comment explains why this was configured this way:

// Keep fetch and the dispatcher on the same undici implementation. Node 26.0's
// bundled fetch can otherwise consume compressed responses through npm undici's
// dispatcher without decompressing them, causing response.json() failures.
// If a caller replaced fetch after module load, preserve that deliberate override.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

How to build a custom Claude plugin?

Ramu Narasinga — Thu, 18 Jun 2026 15:00:00 +0000

In this article, you will learn how to build a custom Claude plugin. We will look at the following:

What is a Claude plugin?
Build a simple Claude plugin.

What is a Claude plugin?

You can create custom plugins to extend Claude Code with skills, agents, hooks, and MCP servers. Plugins let you extend Claude Code with custom functionality that can be shared across projects and teams.

When to use a plugin?

You can use a plugin when you want to share directories containing skills, agents, hooks etc., with teammates, things that are reusable across projects.

There is a also a standalone configuration, defined in .claude folder and this can be specific to a project, can include personal workflows or for quick experiments.

Learn more about when to use a plugin vs standalone configuration.

Let’s build a simple plugin following the official docs quick start guide..

Build a simple Claude plugin

There are 5 steps involved to create your first plugin.

Create the plugin directory

mkdir my-first-plugin

This folder can contain:

Skills
Agents or hooks
optionally, a .claude-plugin/plugin.json manifest

Create the plugin manifest.

You will define the metadata such as name, description, and version of your plugin. In plugin manager, this info is used by Claude Code to display your plugin.

// run this first
mkdir my-first-plugin/.claude-plugin

and then add this to my-first-plugin/.claude-plugin/plugin.json.

{
  "name": "my-first-plugin",
  "description": "A greeting plugin to learn the basics",
  "version": "1.0.0",
  "author": {
    "name": "Your Name"
  }
}

Learn more about the manifest schema..

Add a skill

Skills are added in the skills/ directory. Folder name becomes the skill name. First, create the skills directory in your plugin folder:

mkdir -p my-first-plugin/skills/helloaxios zustand

Then create the SKILL.md file in my-first-plugin/skills/hello/ folder:

---
description: "Greet the user with a friendly message"
disable-model-invocation: true
---

Greet the user warmly and ask how you can help them today.

Test your plugin

You need to load your plugin by running the below command:

claude --plugin-dir ./my-first-plugin

Once the Claude Code starts, you can try your new skill by running the below command:

/my-first-plugin:hello

You’ll see Claude respond with a greeting. Run /help to see your skill listed under the plugin namespace.

Add a skill argument

You can pass user input as an argument to your skill to make it dynamic. $ARGUMENTS placeholder captures any text user provides after the skill name.

Update your SKILL.md to use this $ARGUMENTS variable in your file.

---
description: Greet the user with a personalized message
---

# Hello Skill

Greet the user named "$ARGUMENTS" warmly and ask how you can help them today. Make the greeting personal and encouraging.

At this point, it is important that you run /reload-plugins to pick up changes and then you can run your skill as shown below:

/my-first-plugin:hello Ram

Claude will greet you by name.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

DEV Community: Ramu Narasinga

warden.toml in Openwork codebase.

What is Warden?

Warden.toml file

Openwork's warden.toml file

About me:

References:

openwork, the open-source alternative to Claude Cowork.

What is Openwork?

Features

How to use OpenWork to automate the built-in browser?

About me:

References:

Voicebox, the open-source AI voice studio.

What is Voicebox?

Features

API

About me:

References:

TencentDB Agent Memory, a team-level memory hub for AI Agents.

What is TencentDB Agent Memory?

How is Agent Memory implemented?

About me:

References:

Alchemy, an Infrastructure-as-Effects framework.

What is Alchemy?

Quick start guide:

alchemy.run.ts file in OSS projects.

t3code/infra/relay/alchemy.run.ts

open-seo/alchemy.run.ts

About me:

References:

Browser Use, Make websites accessible for AI agents.

What is Browser Use

Use cases

Quickstart guide

Python library: the easiest way to automate the web

About me:

References:

Page Agent, the GUI Agent Living in Your Webpage.

What is Page Agent?

Features

Setup

Usecases

About me:

References:

Caveman, a Claude Code skill that cut 65% of tokens.

What is Caveman?

Setup

About me:

References:

`acquireLock` function in claude-context codebase.

What is claude-context?

Setup

saveCodebaseSnapshot

acquireLock function explained.

About me:

References:

Hunk, terminal diffs for humans and agents.

What is Hunk??

Features

Quick start

Working with Git

Working with agents

Modem

Build what’s actually important

Act on problems you didn’t know you had

About me:

References:

`undici.setGlobalDispatcher` function in pi-coding-agent package.

What is pi-coding-agent?

What is Undici?

Why Use the Standalone Package?

setGlobalDispatcher method in pi-coding-agent

undici.setGlobalDispatcher(dispatcher)

About me:

References:

How to build a custom Claude plugin?

What is a Claude plugin?

When to use a plugin?

`acquireLock` function explained.