Explanation: facets=0.00 lexical=0.62 semantic=0.00 confidence=1.00 freshness=1.00

Capture: Pricing | Software automation tool for your business

Pricing | Software automation tool for your business Integrate your bookings with MATCHi Learn more Pricing Resources For clients Request demo English Spanish French Czech Create account Software that grows with your business Matchable is subscription-free for venues, independent trainers, and organizers. For business For freelancers For venues or academies Matchable takes as low as 1.8% to keep the engines running. Pay only when receiving a payment. No upfront fees, no hidden costs, not for you, not for your client. Accept payments in 36+ countries Keep track through the trainer application Add your availability and holidays Add your certifications, skills and more Instantly receive payments 1.8% / Per transaction Create account Request demo Features Private training service Unlimited services Classes and events Unlimited schedules Courses Coming soon Unlimited seasons Promotion tools Free Automated invoices Free Client CRM Unlimited clients Insights Coming soon Coming soon Recruitment Venue profile Manager Web-only manager to manage your everyday Trainer application Let your trainers manager their profile, bookings, availabilities and more. Free Multi-venue management Manage multiple venues from your manager Unlimited venues Manager seats Add multiple manager to your account Unlimited seats Payments Online payments You only pay when you get paid. Simple as that. We only take a small commission when you receive money through a booking. * Stripe or Mollie will also charge standard processing fees, which depend on the payment method selected. 1.8%* Subscription fee No monthly fee, no hidden costs Free Client fee Matchable doesn't monetise your clients, not now, not ever. Fair and square. Free Manual payment links Coming soon Coming soon In-person payments Coming soon Coming soon Manual bookings Free Matchable Marketplace (optional) No additional fee applied to new clients who discover your business via the marketplace. Free Optional add-ons Matchable Widget Show your services and activities on your own website through our widget. On request Google Calendar View your Matchable bookings in your own Apple or Google calendar. Free Stripe Receive payments Free Mollie Receive payments Free MATCHi Automate court bookings Free Coming soon Google Analytics Automate court bookings Coming soon Coming soon Meta Pixel Automate court bookings Coming soon Support Chat support Available through Manager Panel Email support Response within 24 hours Knowledge base Video Support Dedicated agent For freelancers or organisers Matchable takes as low as 1.8% to keep the engines running. Pay only when receiving a payment. No upfront fees, no hidden costs, not for you, not for your client. Accept payments in 36+ countries Manage your trainers and activities Automate your back-office Unlimited connected trainers Instantly receive payments 1.8% / Per transaction Create account Request demo Features Private training service Unlimited services Classes and events Unlimited schedules Courses Coming soon Unlimited seasons Promotion tools Free Automated invoices Free Client CRM Unlimited clients Insights Coming soon Coming soon Recruitment - Venue profile - Manager Web-only manager to manage your everyday Trainer application Let your trainers manager their profile, bookings, availabilities and more. Free Multi-venue management Manage multiple venues from your manager Unlimited venues Manager seats Add multiple manager to your account - Payments Online payments You only pay when you get paid. Simple as that. We only take a small commission when you receive money through a booking. * Stripe or Mollie will also charge standard processing fees, which depend on the payment method selected. 1.8%* Subscription fee No monthly fee, no hidden costs Free Client fee Matchable doesn't monetise your clients, not now, not ever. Fair and square. Free Manual payment links Coming soon Coming soon In-person payments Coming soon Coming soon Manual bookings Free Matchable Marketplace (optional) No additional fee applied to new clients who discover your business via the marketplace. Free Optional add-ons Matchable Widget Show your services and activities on your own website through our widget. Free Google Calendar View your Matchable bookings in your own Apple or Google calendar. Free Stripe Receive payments Free Mollie Receive payments Free MATCHi Automate court bookings Free Google Analytics Automate court bookings Coming soon Meta Pixel Automate court bookings Coming soon Support Chat support Available through Manager Panel Email support Response within 24 hours Knowledge base Video Support - Dedicated agent - Freelancer Business Pricing? Glad you asked Matchable takes as low as 1.8% to keep the engines running. Pay only when receiving a payment. No upfront fees, no hidden costs, not for you, not for your client. Accept payments in 36+ countries Keep track through the trainer application Add your availability and holidays Add your certifications, skills and more Instantly receive payments 1.8% / Per transaction Create account Request demo Manage your trainers and activities Automate your back-office Unlimited connected trainers Instantly receive payments 1.8% / Per transaction Create account Request demo Features Private training service Unlimited services Classes and events Unlimited schedules Courses Coming soon Unlimited seasons Promotion tools Free Automated invoices Free Client CRM Unlimited clients Insights Coming soon Coming soon Recruitment - Venue profile - Manager Web-only manager to manage your everyday Trainer application Let your trainers manager their profile, bookings, availabilities and more. Free Multi-venue management Manage multiple venues from your manager Unlimited venues Manager seats Add multiple manager to your account - Unlimited seats Payments Online payments You only pay when you get paid. Simple as that. We only take a small commission when you receive money through a booking. * Stripe or Mollie will also charge standard processing fees, which depend on the payment method selected. 1.8%* 1.8%* Subscription fee No monthly fee, no hidden costs Free Client fee Matchable doesn't monetise your clients, not now, not ever. Fair and square. Free Manual payment links Coming soon Coming soon In-person payments Coming soon Coming soon Manual bookings Free Matchable Marketplace (optional) No additional fee applied to new clients who discover your business via the marketplace. Free Optional add-ons Matchable Widget Show your services and activities on your own website through our widget. Free On request Google Calendar View your Matchable bookings in your own Apple or Google calendar. Free Stripe Receive payments Free Mollie Receive payments Free MATCHi Automate court bookings On request Coming soon Google Analytics Automate court bookings Coming soon Coming soon Meta Pixel Automate court bookings Coming soon Support Chat support Available through Manager Panel Email support Response within 24 hours Knowledge base Video Support - Dedicated agent - Frequently asked questions. Answered. What is Matchable? Matchable is an academy automation tool and a global marketplace in one. Trainers and venues can showcase themselves to clients and businesses to get booked instantly. You can automate lessons bookings, trainer schedules and court reservations. Players book and pay in Matchable and courts are auto-assigned in real time through MATCHi. How can I join Matchable as a venue or a trainer? We’d love to have you on the platform! Visit this page to register and we'll reach out to you as soon as possible. Is there a cost for using Matchable? Matchable takes as low as 1.8% to keep the engines running. Pay only when receiving a payment. No upfront fees, no hidden costs, not for you, not for your client. Can I still use MATCHi for my bookings? Yes, for sure! The integration is only visible in the back-office admin of the Matchable Manager. How do I offer private training as a service using Matchable and MATCHi? It’s very easy. The first step is to request your account, and from there, read this article for the step by step guide. How do I integrate with Matchable as a MATCHi club? You only have to register once, and we’ll guide you through the integration process, read the full article here for onboarding . How to contact you if I have any additional questions? We’re happy to hear from you, so you can contact us for an introduction call here or send us an email at info@getmatchable.com . Does Matchable have an App? Yes, we have a Trainer App and Client App that we recently launched. You can download them in the Apple Store or on Google Play . Marketplace Log in Create account List your business Report a bug Support Request demo Talk to sales Help Center Voucher balance Contact us Company Integrations Partnerships Company news Work with us Investor portal Tools Resource overview Talent interviews Press kit © 2025 Matchable Privacy Policy Terms of Service Cookies Settings Follow-us

Pricing | Software automation tool for your business

Summary: Pricing | Software automation tool for your business

Explanation: facets=0.00 lexical=0.12 semantic=1.00 confidence=0.75 freshness=0.75

Capture: How to book a training | Matchable

How to book a training | Matchable Help center Go to Matchable Czech English Spanish All collections For clients How to book a training How to book a training This article explains how to purchase a training. Open https://www.getmatchable.com/ and search for your preferred venue/trainer or sport using the search bar. Under ‘Trainers’ , you can find the trainer you’d like to book a training with. Select your trainer, or view their profile if you’d like to know more about their skills or read their reviews. Then select ‘Continue’ to proceed with the booking. As shown below, you can select the type of training. In this case, the trainer offers a ‘group lesson’ during peak and off-peak hours, as well as a ‘private 1-to-1 lesson’ . Select your preferred option. Select Number of Attendees After selecting your preference, choose the number of people who would like to attend the training. Select Training Duration Then, select the duration of the training session. Choose Your Package Select your ‘package’ . Many trainers offer discounts when you book more than one class. Review Your Purchase On the right, you’ll see a summary of your purchase. Apply Discount or Voucher Code If you have a discount or voucher code, you can apply it here. Click ‘Apply’ to activate your code. Continue to Planning Once you’re ready, click ‘Continue to planning’ to finalize your booking. You can plan your training session here, or choose to do it at a later stage. By clicking ‘Plan’ , you can check the trainer’s availability. Click your preferred date and time slot, then select ‘Confirm’ . You can log in to your existing account or create an account. Once you’ve done this, click ‘Pay’ to proceed with the payment. You will receive a confirmation email when you’ve purchased the training. Did this answer your question? 😞 😐 😁

How to book a training | Matchable

Summary: How to book a training | Matchable

Explanation: facets=0.00 lexical=0.12 semantic=0.99 confidence=0.75 freshness=0.75

Sebas work philosophy

Work has two roles for Sebas: it is a way to find meaning and satisfaction through earned achievements, because nothing is given for free; but it should not become the main search of life. Instead, work should enable personal challenges and personal improvement.

Summary: Work should provide earned meaning, but should remain an enabler for life rather than life itself.

Explanation: facets=0.00 lexical=0.12 semantic=0.99 confidence=0.98 freshness=1.00

Sebas life philosophy: love and high-level challenges

A well-lived life for Sebas is one shared with people who love him, plus the fulfillment of high-level personal challenges.

Summary: Well-lived life = shared love + fulfilled high-level personal challenges.

Explanation: facets=0.00 lexical=0.12 semantic=0.98 confidence=0.99 freshness=1.00

Research claim: Existe desalineacion publica entre superficies y madurez: pricing marca courses,

Existe desalineacion publica entre superficies y madurez: pricing marca courses, insights, manual payment links e in-person payments como coming soon, pero help center y release notes del client app ya documentan courses y credits como experiencias operativas.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.88 freshness=0.75

Research claim: A general community-style guide (By AI Team) frames memory lifecycle management

A general community-style guide (By AI Team) frames memory lifecycle management as write policies, summarization, deduplication, and decay/TTL plus governance controls (PII, access rules) to prevent bloat and stale or unsafe recall.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.40 freshness=0.75

Research claim: Made-in-China currently lists multiple outdoor Android/high-brightness signage v

Made-in-China currently lists multiple outdoor Android/high-brightness signage variants in the 55-65 inch range, which is enough to build a shortlist without locking one supplier yet.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.77 freshness=0.70

Legacy task: User clarified: prioritize covered padel clubs first, not direct-sunlight courts

User clarified: prioritize covered padel clubs first, not direct-sunlight courts
kind=clarification
status=noted
notes=

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.65 freshness=0.60

Disambiguation rule for two Sebastians in Ballbox context

In Ballbox context, Sebas refers to Sebastian Favaron unless the conversation explicitly says Seba, which usually refers to Sebastian Vekselman. Avoid confusing the two.

Summary: Ballbox disambiguation: Sebas = Sebastian Favaron; Seba usually = Sebastian Vekselman.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.97 freshness=1.00

Research run: Source 50+ inch China displays for Ballbox advertising in padel venues

Goal: Source 50+ inch China displays for Ballbox advertising in padel venues
Scope: Made-in-China, Alibaba, similar suppliers; indoor or outdoor; browser/fullscreen capable preferred
Assumptions: Need shortlist first, not final purchase decision
Summary: Source 50+ inch China displays for Ballbox advertising in padel venues

Need shortlist first, not final purchase decision

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.85 freshness=0.80

Legacy task: Usuario aclaró: el comportamiento deseado es un input poco intrusivo, transparen

Usuario aclaró: el comportamiento deseado es un input poco intrusivo, transparente, fuera de la pantalla principal de la película y visible solo cuando haga falta responder
kind=clarification
status=noted
notes=

Capture: Integrations

Integrations Integrate your bookings with MATCHi Learn more Pricing Resources For clients Request demo English Spanish French Czech Create account Integrations Integrations your tools We don’t get in the way of tools you love, we integrate with them. From booking platforms to calendars. We keep your day-to-day in sync and eliminates manual busywork. BenFit Connect your Matchable coaches to BenFit nutrition support. Give your clients a complete training and nutrition experience. Read more PadelFast Connect your Matchable training clients to PadelFast tournaments. Organize students into competitions easily. Read more Google Calendar Two-way sync between Matchable and Google Calendar. Block time in either place, both calendars update. Read more Matchpoint Training bookings on Matchable automatically reserve courts in Matchpoint. Full two-way sync. Read more Google Meet Offer online training sessions with automatic Google Meet links added to every booking. Read more KNLTB Meet & Play Book training sessions through Matchable, courts reserve automatically in KNLTB. Sessions appear in the KNLTB app. Read more AnyBuddy Sync training bookings with AnyBuddy courts automatically. One booking reserves both trainer and court. Read more MATCHi Automatic court booking when clients book private training. Courts sync in real-time across both platforms. Read more Taykus Private training bookings automatically reserve courts in Taykus. Changes sync in real-time. Read more Integrate with Matchable Ready to join our mission to make sports more accessible? Schedule a call Marketplace Log in Create account List your business Report a bug Support Request demo Talk to sales Help Center Voucher balance Contact us Company Integrations Partnerships Company news Work with us Investor portal Tools Resource overview Talent interviews Press kit © 2025 Matchable Privacy Policy Terms of Service Cookies Settings Follow-us

Integrations

Summary: Integrations

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.75 freshness=0.75

Sebas definition of finishing well

For Sebas, finishing something well means publishing it, showing it to people, and feeling satisfied with the result.

Summary: Finish well = publish it, show it, feel satisfied.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.99 freshness=1.00

Legacy task: User clarified: covered clubs first

User clarified: covered clubs first
kind=clarification
status=noted
notes=

Summary: User clarified: covered clubs first

Capture: Help center | Matchable

Help center | Matchable Help center Go to Matchable Czech English Spanish Find answers to your questions Quick start guide Your step-by-step path to getting started For clients Booking and paying Trainer app [IOS/Android] Set yourself up to be bookable on Matchable, and manage your availabilities and holidays. Business Manager In this category you will find all articles related to venues and trainers

Help center | Matchable

Summary: Help center | Matchable

Research run: Find China-sourced 50+ inch displays for Ballbox advertising in covered padel clubs

Goal: Find China-sourced 50+ inch displays for Ballbox advertising in covered padel clubs
Scope: Prioritize covered clubs first; shortlist suppliers/screens from Alibaba, Made-in-China, or similar
Assumptions: Fullscreen browser preferred; exact hardware/software stack can be validated later; no final purchase decision yet
Summary: Find China-sourced 50+ inch displays for Ballbox advertising in covered padel clubs

Phase 2 runtime continuation package

Next work under the agentic runtime refactor is packaged as a parent task plus five concrete subtasks covering richer action types, approval resume, resumability state, operator visibility, and end-to-end verification.

Summary: Shared DB now contains a Phase 2 continuation package for the runtime refactor.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.98 freshness=1.00

Research claim: Trading-Mastery is a real public GitHub organization account created on 2024-09-

Trading-Mastery is a real public GitHub organization account created on 2024-09-12 with zero public repositories and no public profile links or contact metadata.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.99 freshness=0.70

Research claim: Para racquet clubs, la propuesta diferencial visible es automatizar la asignacio

Para racquet clubs, la propuesta diferencial visible es automatizar la asignacion de canchas al reservar entrenamientos mediante integraciones con MATCHi, Matchpoint, KNLTB Meet & Play, AnyBuddy y Taykus.

Explanation: facets=0.00 lexical=0.00 semantic=1.00 confidence=0.94 freshness=0.75


**Researching tools and philosophies**

I need to research Mario's article and potentially explore other sources. I could fetch the article directly or use prior content, but I want fresh data. It might be beneficial to look into different philosophies, specifically discoverability/context-loading and composability/Unix. I need to confirm that skills are loaded correctly into context and consider the behaviors of tools as skills versus tool wrappers. I’ll gather evidence from the relevant documentation and seek out additional opinions.

**Searching for skills opinions**

I could search the web using Brave, but I don't have a specific skill in mind. Instead, I might utilize curl or general web tools to fetch article text. The user mentioned Mario and others, so gathering insights from different sources, like the OpenAI docs on "skills vs tools," would be useful. I'll aim for a couple of articles, incorporating perspectives from Anthropic’s skills docs. It could be worthwhile to look for opinions on "LLM skills frontmatter" or "Anthropic skills." Let's get searching!

bash

curl -L --max-time 20 -s 'https://r.jina.ai/http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/' | sed -n '1,260p'

curl -L --max-time 20 -s 'https://r.jina.ai/http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md' | sed -n '1,220p'

curl -L --max-time 20 -s 'https://r.jina.ai/http://duckduckgo.com/html/?q=LLM+skills+frontmatter+tools+unix+philosophy' | sed -n '1,220p'


Title: What if you don't need MCP at all?

URL Source: http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/

Markdown Content:
2025-11-02

![Image 1](https://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/media/header.png)

One chonky MCP server

*   [My Browser DevTools Use Cases](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_0)
*   [Problems with Common Browser DevTools for Your Agent](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_1)
*   [Embracing Bash (and Code)](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_2)
    *   [The Start Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_3)
    *   [The Navigate Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_4)
    *   [The Evaluate JavaScript Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_5)
    *   [The Screenshot Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_6)

*   [The Benefits](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_7)
*   [Adding the Pick Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_8)
*   [Adding the Cookies Tool](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_9)
*   [A Contrived Example](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_10)
*   [Making This Reusable Across Agents](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_11)
*   [In Conclusion](http://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/#toc_12)

After months of agentic coding frenzy, Twitter is still ablaze with discussions about MCP servers. I previously did some [very light benchmarking](https://mariozechner.at/posts/2025-08-15-mcp-vs-cli/) to see if Bash tools or MCP servers are better suited for a specific task. The TL;DR: both can be efficient if you take care.

Unfortunately, many of the most popular MCP servers are inefficient for a specific task. They need to cover all bases, which means they provide large numbers of tools with lengthy descriptions, consuming significant context.

It's also hard to extend an existing MCP server. You could check out the source and modify it, but then you'd have to understand the codebase, together with your agent.

MCP servers also aren't composable. Results returned by an MCP server have to go through the agent's context to be persisted to disk or combined with other results.

I'm a simple boy, so I like simple things. Agents can run Bash and write code well. Bash and code are composable. So what's simpler than having your agent just invoke CLI tools and write code? This is nothing new. We've all been doing this since the beginning. I'd just like to convince you that in many situations, you don't need or even want an MCP server.

Let me illustrate this with a common MCP server use case: browser dev tools.

## My Browser DevTools Use Cases

My use cases are working on web frontends together with my agent, or abusing my agent to become a scrapey little hacker boy so I can scrape all the data in the world. For these two use cases, I only need a minimal set of tools:

*   Start the browser, optionally with my default profile so I'm logged in
*   Navigate to a URL, either in the active tab or a new tab
*   Execute JavaScript in the active page context
*   Take a screenshot of the viewport

And if my use case requires additional special tooling, I want to quickly have my agent generate that for me and slot it in with the other tools.

## Problems with Common Browser DevTools for Your Agent

People will recommend [Playwright MCP](https://github.com/microsoft/playwright-mcp) or [Chrome DevTools MCP](https://github.com/ChromeDevTools/chrome-devtools-mcp) for the use cases I illustrated above. Both are fine, but they need to cover all the bases. Playwright MCP has 21 tools using 13.7k tokens (6.8% of Claude's context). Chrome DevTools MCP has 26 tools using 18.0k tokens (9.0%). That many tools will confuse your agent, especially when combined with other MCP servers and built-in tools.

Using those tools also means you suffer from the composability issue: any output has to go through your agent's context. You can kind of fix this by using sub-agents, but then you rope in all the issues that sub-agents come with.

## Embracing Bash (and Code)

Here's my minimal set of tools, illustrated via the README.md:

```
# Browser Tools

Minimal CDP tools for collaborative site exploration.

## Start Chrome

\`\`\`bash
./start.js              # Fresh profile
./start.js --profile    # Copy your profile (cookies, logins)
\`\`\`

Start Chrome on `:9222` with remote debugging.

## Navigate

\`\`\`bash
./nav.js https://example.com
./nav.js https://example.com --new
\`\`\`

Navigate current tab or open new tab.

## Evaluate JavaScript

\`\`\`bash
./eval.js 'document.title'
./eval.js 'document.querySelectorAll("a").length'
\`\`\`

Execute JavaScript in active tab (async context).

## Screenshot

\`\`\`bash
./screenshot.js
\`\`\`

Screenshot current viewport, returns temp file path.
```

This is all I feed to my agent. It's a handful of tools that cover all the bases for my use case. Each tool is a simple Node.js script that uses [Puppeteer Core](https://pptr.dev/). By reading that README, the agent knows the available tools, when to use them, and how to use them via Bash.

When I start a session where the agent needs to interact with a browser, I just tell it to read that file in full and that's all it needs to be effective. Let's walk through their implementations to see how little code this actually is.

### The Start Tool

The agent needs to be able to start a new browser session. For scraping tasks, I often want to use my actual Chrome profile so I'm logged in everywhere. This script either rsyncs my Chrome profile to a temporary folder (Chrome doesn't allow debugging on the default profile), or starts fresh:

```
#!/usr/bin/env node

import { spawn, execSync } from "node:child_process";
import puppeteer from "puppeteer-core";

const useProfile = process.argv[2] === "--profile";

if (process.argv[2] && process.argv[2] !== "--profile") {
	console.log("Usage: start.ts [--profile]");
	console.log("\nOptions:");
	console.log("  --profile  Copy your default Chrome profile (cookies, logins)");
	console.log("\nExamples:");
	console.log("  start.ts            # Start with fresh profile");
	console.log("  start.ts --profile  # Start with your Chrome profile");
	process.exit(1);
}

// Kill existing Chrome
try {
	execSync("killall 'Google Chrome'", { stdio: "ignore" });
} catch {}

// Wait a bit for processes to fully die
await new Promise((r) => setTimeout(r, 1000));

// Setup profile directory
execSync("mkdir -p ~/.cache/scraping", { stdio: "ignore" });

if (useProfile) {
	// Sync profile with rsync (much faster on subsequent runs)
	execSync(
		'rsync -a --delete "/Users/badlogic/Library/Application Support/Google/Chrome/" ~/.cache/scraping/',
		{ stdio: "pipe" },
	);
}

// Start Chrome in background (detached so Node can exit)
spawn(
	"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
	["--remote-debugging-port=9222", `--user-data-dir=${process.env["HOME"]}/.cache/scraping`],
	{ detached: true, stdio: "ignore" },
).unref();

// Wait for Chrome to be ready by attempting to connect
let connected = false;
for (let i = 0; i < 30; i++) {
	try {
		const browser = await puppeteer.connect({
			browserURL: "http://localhost:9222",
			defaultViewport: null,
		});
		await browser.disconnect();
		connected = true;
		break;
	} catch {
		await new Promise((r) => setTimeout(r, 500));
	}
}

if (!connected) {
	console.error("✗ Failed to connect to Chrome");
	process.exit(1);
}

console.log(`✓ Chrome started on :9222${useProfile ? " with your profile" : ""}`);
```

All the agent needs to know is to use Bash to run the start.js script, either with `--profile` or without.

### The Navigate Tool

Once the browser is running, the agent needs to navigate to URLs, either in a new tab or the active tab. That's exactly what the navigate tool provides:

```
#!/usr/bin/env node

import puppeteer from "puppeteer-core";

const url = process.argv[2];
const newTab = process.argv[3] === "--new";

if (!url) {
	console.log("Usage: nav.js <url> [--new]");
	console.log("\nExamples:");
	console.log("  nav.js https://example.com       # Navigate current tab");
	console.log("  nav.js https://example.com --new # Open in new tab");
	process.exit(1);
}

const b = await puppeteer.connect({
	browserURL: "http://localhost:9222",
	defaultViewport: null,
});

if (newTab) {
	const p = await b.newPage();
	await p.goto(url, { waitUntil: "domcontentloaded" });
	console.log("✓ Opened:", url);
} else {
	const p = (await b.pages()).at(-1);
	await p.goto(url, { waitUntil: "domcontentloaded" });
	console.log("✓ Navigated to:", url);
}

await b.disconnect();
```

### The Evaluate JavaScript Tool

The agent needs to execute JavaScript to read and modify the DOM of the active tab. The JavaScript it writes runs in the page context, so it doesn't have to fuck around with Puppeteer itself. All it needs to know is how to write code using the DOM API, and it sure knows how to do that:

```
#!/usr/bin/env node

import puppeteer from "puppeteer-core";

const code = process.argv.slice(2).join(" ");
if (!code) {
	console.log("Usage: eval.js 'code'");
	console.log("\nExamples:");
	console.log('  eval.js "document.title"');
	console.log('  eval.js "document.querySelectorAll(\'a\').length"');
	process.exit(1);
}

const b = await puppeteer.connect({
	browserURL: "http://localhost:9222",
	defaultViewport: null,
});

const p = (await b.pages()).at(-1);

if (!p) {
	console.error("✗ No active tab found");
	process.exit(1);
}

const result = await p.evaluate((c) => {
	const AsyncFunction = (async () => {}).constructor;
	return new AsyncFunction(`return (${c})`)();
}, code);

if (Array.isArray(result)) {
	for (let i = 0; i < result.length; i++) {
		if (i > 0) console.log("");
		for (const [key, value] of Object.entries(result[i])) {
			console.log(`${key}: ${value}`);
		}
	}
} else if (typeof result === "object" && result !== null) {
	for (const [key, value] of Object.entries(result)) {


Title: pi-skills/browser-tools/SKILL.md at main · badlogic/pi-skills

URL Source: http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md

Markdown Content:
| name | browser-tools |
| --- |
| description | Interactive browser automation via Chrome DevTools Protocol. Use when you need to interact with web pages, test frontends, or when user interaction with a visible browser is required. |

Chrome DevTools Protocol tools for agent-assisted web automation. These tools connect to Chrome running on `:9222` with remote debugging enabled.

## Setup

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#setup)
Run once before first use:

cd {baseDir}/browser-tools
npm install

## Start Chrome

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#start-chrome)

{baseDir}/browser-start.js              # Fresh profile
{baseDir}/browser-start.js --profile    # Copy user's profile (cookies, logins)

Launch Chrome with remote debugging on `:9222`. Use `--profile` to preserve user's authentication state.

## Navigate

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#navigate)

{baseDir}/browser-nav.js https://example.com
{baseDir}/browser-nav.js https://example.com --new

Navigate to URLs. Use `--new` flag to open in a new tab instead of reusing current tab.

## Evaluate JavaScript

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#evaluate-javascript)

{baseDir}/browser-eval.js 'document.title'
{baseDir}/browser-eval.js 'document.querySelectorAll("a").length'

Execute JavaScript in the active tab. Code runs in async context. Use this to extract data, inspect page state, or perform DOM operations programmatically.

## Screenshot

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#screenshot)

{baseDir}/browser-screenshot.js

Capture current viewport and return temporary file path. Use this to visually inspect page state or verify UI changes.

## Pick Elements

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#pick-elements)

{baseDir}/browser-pick.js "Click the submit button"

**IMPORTANT**: Use this tool when the user wants to select specific DOM elements on the page. This launches an interactive picker that lets the user click elements to select them. The user can select multiple elements (Cmd/Ctrl+Click) and press Enter when done. The tool returns CSS selectors for the selected elements.

Common use cases:

*   User says "I want to click that button" → Use this tool to let them select it
*   User says "extract data from these items" → Use this tool to let them select the elements
*   When you need specific selectors but the page structure is complex or ambiguous

## Cookies

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#cookies)

{baseDir}/browser-cookies.js

Display all cookies for the current tab including domain, path, httpOnly, and secure flags. Use this to debug authentication issues or inspect session state.

## Extract Page Content

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#extract-page-content)

{baseDir}/browser-content.js https://example.com

Navigate to a URL and extract readable content as markdown. Uses Mozilla Readability for article extraction and Turndown for HTML-to-markdown conversion. Works on pages with JavaScript content (waits for page to load).

## When to Use

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#when-to-use)
*   Testing frontend code in a real browser
*   Interacting with pages that require JavaScript
*   When user needs to visually see or interact with a page
*   Debugging authentication or session issues
*   Scraping dynamic content that requires JS execution

* * *

## Efficiency Guide

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#efficiency-guide)
### DOM Inspection Over Screenshots

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#dom-inspection-over-screenshots)
**Don't** take screenshots to see page state. **Do** parse the DOM directly:

// Get page structure
document.body.innerHTML.slice(0, 5000)

// Find interactive elements
Array.from(document.querySelectorAll('button, input, [role="button"]')).map(e => ({
  id: e.id,
  text: e.textContent.trim(),
  class: e.className
}))

### Complex Scripts in Single Calls

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#complex-scripts-in-single-calls)
Wrap everything in an IIFE to run multi-statement code:

(function() {
  // Multiple operations
  const data = document.querySelector('#target').textContent;
  const buttons = document.querySelectorAll('button');

  // Interactions
  buttons[0].click();

  // Return results
  return JSON.stringify({ data, buttonCount: buttons.length });
})()

### Batch Interactions

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#batch-interactions)
**Don't** make separate calls for each click. **Do** batch them:

(function() {
  const actions = ["btn1", "btn2", "btn3"];
  actions.forEach(id => document.getElementById(id).click());
  return "Done";
})()

### Typing/Input Sequences

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#typinginput-sequences)

(function() {
  const text = "HELLO";
  for (const char of text) {
    document.getElementById("key-" + char).click();
  }
  document.getElementById("submit").click();
  return "Submitted: " + text;
})()

### Reading App/Game State

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#reading-appgame-state)
Extract structured state in one call:

(function() {
  const state = {
    score: document.querySelector('.score')?.textContent,
    status: document.querySelector('.status')?.className,
    items: Array.from(document.querySelectorAll('.item')).map(el => ({
      text: el.textContent,
      active: el.classList.contains('active')
    }))
  };
  return JSON.stringify(state, null, 2);
})()

### Waiting for Updates

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#waiting-for-updates)
If DOM updates after actions, add a small delay with bash:

sleep 0.5 && {baseDir}/browser-eval.js '...'

### Investigate Before Interacting

[](http://github.com/badlogic/pi-skills/blob/main/browser-tools/SKILL.md#investigate-before-interacting)
Always start by understanding the page structure:

(function() {
  return {
    title: document.title,
    forms: document.forms.length,
    buttons: document.querySelectorAll('button').length,
    inputs: document.querySelectorAll('input').length,
    mainContent: document.body.innerHTML.slice(0, 3000)
  };
})()

Then target specific elements based on what you find.


Title: LLM skills frontmatter tools unix philosophy at DuckDuckGo

URL Source: http://duckduckgo.com/html/?q=LLM+skills+frontmatter+tools+unix+philosophy

Markdown Content:
# LLM skills frontmatter tools unix philosophy at DuckDuckGo
[](http://duckduckgo.com/html/?q=LLM+skills+frontmatter+tools+unix+philosophy)

[](http://duckduckgo.com/html/ "DuckDuckGo")

## [Prat011/awesome-llm-skills - GitHub](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fgithub.com%2FPrat011%2Fawesome%2Dllm%2Dskills&rut=438a17dd6d3f464d99413eb9d23071d03160e9e58fe19bad4dfb7d7f915943c3)

[![Image 1](http://external-content.duckduckgo.com/ip3/github.com.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fgithub.com%2FPrat011%2Fawesome%2Dllm%2Dskills&rut=438a17dd6d3f464d99413eb9d23071d03160e9e58fe19bad4dfb7d7f915943c3)[github.com/Prat011/awesome-llm-skills](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fgithub.com%2FPrat011%2Fawesome%2Dllm%2Dskills&rut=438a17dd6d3f464d99413eb9d23071d03160e9e58fe19bad4dfb7d7f915943c3) 2025-10-22T12:42:00.0000000

[A curated list of awesome **LLM****Skills**, resources, and **tools** for customizing AI workflows on **tools** like Claude Code, Codex, Gemini CLI, Qwen Code, OpenCode etc.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fgithub.com%2FPrat011%2Fawesome%2Dllm%2Dskills&rut=438a17dd6d3f464d99413eb9d23071d03160e9e58fe19bad4dfb7d7f915943c3)

## [cwinux/awesome-llm-skills | DeepWiki](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fdeepwiki.com%2Fcwinux%2Fawesome%2Dllm%2Dskills&rut=2a8fd507716728ce6544e874e4147bfd7bd19a9d9721cc66ec17c16d2565183b)

[![Image 2](http://external-content.duckduckgo.com/ip3/deepwiki.com.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fdeepwiki.com%2Fcwinux%2Fawesome%2Dllm%2Dskills&rut=2a8fd507716728ce6544e874e4147bfd7bd19a9d9721cc66ec17c16d2565183b)[deepwiki.com/cwinux/awesome-llm-skills](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fdeepwiki.com%2Fcwinux%2Fawesome%2Dllm%2Dskills&rut=2a8fd507716728ce6544e874e4147bfd7bd19a9d9721cc66ec17c16d2565183b) 2025-12-31T00:00:00.0000000

[The awesome-**llm**-**skills** repository provides a standardized, platform-agnostic framework for creating reusable **LLM** workflows. The **SKILL**.md format ensures portability across multiple AI platforms, while the repository's organization into 10+ categories facilitates **skill** discovery.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fdeepwiki.com%2Fcwinux%2Fawesome%2Dllm%2Dskills&rut=2a8fd507716728ce6544e874e4147bfd7bd19a9d9721cc66ec17c16d2565183b)

## [LLM Wiki Skill: Build a Second Brain With Claude Code and Obsidian](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falirezarezvani.medium.com%2Fllm%2Dwiki%2Dskill%2Dbuild%2Da%2Dsecond%2Dbrain%2Dwith%2Dclaude%2Dcode%2Dand%2Dobsidian%2D2282752758c1&rut=a69056c49deda06635dd03f865de57559824e6b67bbff0ba250ef265ec603f8c)

[![Image 3](http://external-content.duckduckgo.com/ip3/alirezarezvani.medium.com.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falirezarezvani.medium.com%2Fllm%2Dwiki%2Dskill%2Dbuild%2Da%2Dsecond%2Dbrain%2Dwith%2Dclaude%2Dcode%2Dand%2Dobsidian%2D2282752758c1&rut=a69056c49deda06635dd03f865de57559824e6b67bbff0ba250ef265ec603f8c)[alirezarezvani.medium.com/llm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falirezarezvani.medium.com%2Fllm%2Dwiki%2Dskill%2Dbuild%2Da%2Dsecond%2Dbrain%2Dwith%2Dclaude%2Dcode%2Dand%2Dobsidian%2D2282752758c1&rut=a69056c49deda06635dd03f865de57559824e6b67bbff0ba250ef265ec603f8c) 2026-04-12T12:08:35.0000000

[Build Karpathy's **LLM** Wiki pattern as a reusable Claude Code **skill** — complete architecture, two production use cases, and every file you need to get started.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falirezarezvani.medium.com%2Fllm%2Dwiki%2Dskill%2Dbuild%2Da%2Dsecond%2Dbrain%2Dwith%2Dclaude%2Dcode%2Dand%2Dobsidian%2D2282752758c1&rut=a69056c49deda06635dd03f865de57559824e6b67bbff0ba250ef265ec603f8c)

## [The power of the Unix philosophy for LLM agentic tools](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fblog.korny.info%2F2025%2F07%2F11%2Fthe%2Dpower%2Dof%2Dthe%2Dunix%2Dphilosophy%2Dfor%2Dllm%2Dagentic%2Dtools&rut=86dc4c86cf7ac07c6e1ac5fae811e811afe8e348dc0fb4dd8f22a0d44b1767d9)

[![Image 4](http://external-content.duckduckgo.com/ip3/blog.korny.info.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fblog.korny.info%2F2025%2F07%2F11%2Fthe%2Dpower%2Dof%2Dthe%2Dunix%2Dphilosophy%2Dfor%2Dllm%2Dagentic%2Dtools&rut=86dc4c86cf7ac07c6e1ac5fae811e811afe8e348dc0fb4dd8f22a0d44b1767d9)[blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fblog.korny.info%2F2025%2F07%2F11%2Fthe%2Dpower%2Dof%2Dthe%2Dunix%2Dphilosophy%2Dfor%2Dllm%2Dagentic%2Dtools&rut=86dc4c86cf7ac07c6e1ac5fae811e811afe8e348dc0fb4dd8f22a0d44b1767d9) 2025-07-11T00:00:00.0000000

[Back to my main thought - **LLM** code augmentation **tools** work best where they, and their users, embrace **Unix-philosophy****tools** - multiple small **tools** that do one thing each, that interact with simple text-based formats. I can see this being a bit of a struggle, and a culture clash, for people who love the Cathedral model - big complex clever systems.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fblog.korny.info%2F2025%2F07%2F11%2Fthe%2Dpower%2Dof%2Dthe%2Dunix%2Dphilosophy%2Dfor%2Dllm%2Dagentic%2Dtools&rut=86dc4c86cf7ac07c6e1ac5fae811e811afe8e348dc0fb4dd8f22a0d44b1767d9)

## [LLM Engineer Toolkit: 150+ Tools for AI Development (2026)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falexbobes.com%2Fartificial%2Dintelligence%2Fthe%2Dultimate%2Dllm%2Dengineer%2Dtoolkit%2F&rut=dac0420c4b4278516d20291fbf8c5740d129dbfd603ecaa52832c3892b286bba)

[![Image 5](http://external-content.duckduckgo.com/ip3/alexbobes.com.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falexbobes.com%2Fartificial%2Dintelligence%2Fthe%2Dultimate%2Dllm%2Dengineer%2Dtoolkit%2F&rut=dac0420c4b4278516d20291fbf8c5740d129dbfd603ecaa52832c3892b286bba)[alexbobes.com/artificial-intelligence/the-ultimate-llm-engineer-toolkit/](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falexbobes.com%2Fartificial%2Dintelligence%2Fthe%2Dultimate%2Dllm%2Dengineer%2Dtoolkit%2F&rut=dac0420c4b4278516d20291fbf8c5740d129dbfd603ecaa52832c3892b286bba) 2026-02-26T00:00:00.0000000

[This guide organizes over 150 specialized libraries and **tools** that every **LLM** engineer should know in 2026. Each section includes practical implementation guidance, real-world use cases, and strategic considerations based on actual production deployments.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Falexbobes.com%2Fartificial%2Dintelligence%2Fthe%2Dultimate%2Dllm%2Dengineer%2Dtoolkit%2F&rut=dac0420c4b4278516d20291fbf8c5740d129dbfd603ecaa52832c3892b286bba)

## [The Unix Philosophy Meets AI: Building Composable LLM Tools with MCP](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fswiderski.tech%2F2025%2D09%2D02%2Dmcp%2Dtools%2Dllm%2Dmeets%2Dunix%2F&rut=81790fc68ef1f28f50a5107e7d2280ef556968f0d448fb8b40b2df74d78ee131)

[![Image 6](http://external-content.duckduckgo.com/ip3/swiderski.tech.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fswiderski.tech%2F2025%2D09%2D02%2Dmcp%2Dtools%2Dllm%2Dmeets%2Dunix%2F&rut=81790fc68ef1f28f50a5107e7d2280ef556968f0d448fb8b40b2df74d78ee131)[swiderski.tech/2025-09-02-mcp-tools-llm-meets-unix/](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fswiderski.tech%2F2025%2D09%2D02%2Dmcp%2Dtools%2Dllm%2Dmeets%2Dunix%2F&rut=81790fc68ef1f28f50a5107e7d2280ef556968f0d448fb8b40b2df74d78ee131) 2025-09-02T00:00:00.0000000

[We've been thinking about AI development backwards. Instead of building "AI-powered" apps, we should be building **tools** that power AI. The Model Context Protocol lets you create small, focused **tools** that **LLMs** can use autonomously - just like **Unix** commands from 1978, but orchestrated by Claude instead of bash. I built a currency converter **tool** and watched an **LLM** decide when to use it, extract ...](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fswiderski.tech%2F2025%2D09%2D02%2Dmcp%2Dtools%2Dllm%2Dmeets%2Dunix%2F&rut=81790fc68ef1f28f50a5107e7d2280ef556968f0d448fb8b40b2df74d78ee131)

## [The Unix Philosophy for Agentic Coding | Ramblings of a Coder's Mind](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fkarun.me%2Fblog%2F2026%2F03%2F05%2Fthe%2Dunix%2Dphilosophy%2Dfor%2Dagentic%2Dcoding%2F&rut=9d12a321277e6855088fe8ba367fcad0a10761c4e8b769b680b32aaaf9a8bc06)

[![Image 7](http://external-content.duckduckgo.com/ip3/karun.me.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fkarun.me%2Fblog%2F2026%2F03%2F05%2Fthe%2Dunix%2Dphilosophy%2Dfor%2Dagentic%2Dcoding%2F&rut=9d12a321277e6855088fe8ba367fcad0a10761c4e8b769b680b32aaaf9a8bc06)[karun.me/blog/2026/03/05/the-unix-philosophy-for-agentic-coding/](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fkarun.me%2Fblog%2F2026%2F03%2F05%2Fthe%2Dunix%2Dphilosophy%2Dfor%2Dagentic%2Dcoding%2F&rut=9d12a321277e6855088fe8ba367fcad0a10761c4e8b769b680b32aaaf9a8bc06) 2026-03-05T00:00:00.0000000

[Why AI coding agents should orchestrate deterministic **tools** instead of solving every problem themselves, and how the **Unix****philosophy** applies to agentic workflows.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fkarun.me%2Fblog%2F2026%2F03%2F05%2Fthe%2Dunix%2Dphilosophy%2Dfor%2Dagentic%2Dcoding%2F&rut=9d12a321277e6855088fe8ba367fcad0a10761c4e8b769b680b32aaaf9a8bc06)

## [Karpathy's LLM Wiki: The Complete Guide to His Idea File](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fantigravity.codes%2Fblog%2Fkarpathy%2Dllm%2Dwiki%2Didea%2Dfile&rut=4328986a9c06cb32cc5ab5c35d8729b185a1d39c140202ea636adc9a327f3fa0)

[![Image 8](http://external-content.duckduckgo.com/ip3/antigravity.codes.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fantigravity.codes%2Fblog%2Fkarpathy%2Dllm%2Dwiki%2Didea%2Dfile&rut=4328986a9c06cb32cc5ab5c35d8729b185a1d39c140202ea636adc9a327f3fa0)[antigravity.codes/blog/karpathy-llm-wiki-idea-file](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fantigravity.codes%2Fblog%2Fkarpathy%2Dllm%2Dwiki%2Didea%2Dfile&rut=4328986a9c06cb32cc5ab5c35d8729b185a1d39c140202ea636adc9a327f3fa0) 2026-04-04T00:00:00.0000000

[Karpathy shared his **LLM** Wiki idea file as a GitHub gist. We break down every concept, **tool**, and technique — with implementation examples and code.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fantigravity.codes%2Fblog%2Fkarpathy%2Dllm%2Dwiki%2Didea%2Dfile&rut=4328986a9c06cb32cc5ab5c35d8729b185a1d39c140202ea636adc9a327f3fa0)

## [Knowledge Base | Llmcli / The Unix Philosophy for LLM Agents](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fwiki.sophia.host%2FLlmcli%2FLlmcli&rut=8dc84cec63e0e9bbf081ba59eb9deef8c6199b9b589da1932078c6903656f149)

[![Image 9](http://external-content.duckduckgo.com/ip3/wiki.sophia.host.ico)](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fwiki.sophia.host%2FLlmcli%2FLlmcli&rut=8dc84cec63e0e9bbf081ba59eb9deef8c6199b9b589da1932078c6903656f149)[wiki.sophia.host/Llmcli/Llmcli](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fwiki.sophia.host%2FLlmcli%2FLlmcli&rut=8dc84cec63e0e9bbf081ba59eb9deef8c6199b9b589da1932078c6903656f149)

[This collection of **tools** adheres to the **Unix****philosophy** by providing small, maintainable, and chainable C utilities that each perform a single task with precision. Designed for OpenBSD, these components work in conjunction via pipes and files to build robust, transparent **LLM** agents with a minimal bug surface.](http://duckduckgo.com/l/?uddg=https%3A%2F%2Fwiki.sophia.host%2FLlmcli%2FLlmcli&rut=8dc84cec63e0e9bbf081ba59eb9deef8c6199b9b589da1932078c6903656f149)

[Feedback](http://duckduckgo.com/feedback.html)

![Image 10](http://duckduckgo.com/t/sl_h)


**Exploring skills philosophy**

I need to dig deeper into the philosophy of skills. An article from Anthropic might help, or I could reference Claude documentation. Perhaps I should search for “skills as directories with SKILL.md frontmatter.” I need to differentiate between two philosophies: “skill as discoverability/context-packaging” versus “tool as composition boundary.” Skills serve to read instructions and choose tools, rather than act as tool transport. There’s a contrast between packaging for efficiency and reusability. The ideas of distribution format and composable tools can be combined but aren’t the same.

**Analyzing browser-tools and skills**

When discussing browser-tools, the skill loads metadata, while the scripts are the tools themselves. I think I need to clarify that there isn't a substantial philosophical difference among browser-* skills, aside from a single repo skill wrapper. I wonder if there are more browser-* skills to consider. In pi-skills, there’s only one skill. Extra scripts exist, but they aren't separate skills. It's important to mention that too many tools can create context overhead. Efficiency is emphasized, like Mario pointing out the downsides of MCP servers with many tools. I should also look into opinions from other sources about skills and the Unix philosophy on LLM agentic tools.

**Searching for skills frontmatter**

I think it might be better to search for "skills frontmatter" specifically in the documentation. I noticed that a summary from deepwiki/awesome-llm-skills describes it as a standardized, platform-agnostic framework for reusable LLM workflows, which sounds like it’s sufficient. I’m considering doing one more search to gather more information about the portability of `SKILL.md`. This should help solidify my understanding and provide the user with concise and informative insights.

curl -L --max-time 20 -s 'https://r.jina.ai/http://deepwiki.com/cwinux/awesome-llm-skills' | sed -n '1,220p'

curl -L --max-time 20 -s 'https://r.jina.ai/http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools' | sed -n '1,220p'

curl -L --max-time 20 -s 'https://r.jina.ai/http://alirezarezvani.medium.com/llm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1' | sed -n '1,220p'


Title: Overview

URL Source: http://deepwiki.com/cwinux/awesome-llm-skills

Published Time: 2025-12-31T03:25:59.823237

Markdown Content:
Relevant source files
*   [README.md](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1)

This document introduces the awesome-llm-skills repository, a centralized collection of customizable workflows for Large Language Models (LLMs). It covers the fundamental SKILL.md format, platform integration approaches, skill discovery mechanisms, and repository organization. For platform-specific implementation details, see [Platform Integration](https://deepwiki.com/cwinux/awesome-llm-skills/3-platform-integration). For skill creation guidelines, see [Creating Skills](https://deepwiki.com/cwinux/awesome-llm-skills/4-creating-skills). For detailed documentation of individual skill categories, see [Skill Categories](https://deepwiki.com/cwinux/awesome-llm-skills/5-skill-categories).

## Purpose and Scope

The awesome-llm-skills repository serves as a curated marketplace of standardized LLM workflows that enable consistent task execution across multiple AI platforms. Each skill is a self-contained package with instructions, examples, and optional supporting files that teach LLMs to perform specialized tasks—from document processing to Notion integration to development automation.

**Sources:**[README.md 1-51](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L1-L51)

## What Are LLM Skills?

LLM Skills are instruction sets packaged in a standardized format that teach language models to execute specific workflows repeatably and consistently. Unlike one-off prompts, skills provide structured guidance with examples, edge case handling, and reusable patterns that work across different LLM platforms.

### Key Characteristics

| Characteristic | Description |
| --- | --- |
| **Portability** | Single SKILL.md format works across Claude Code, Claude Desktop, Codex CLI, Gemini CLI, OpenCode, and Qwen Code |
| **Repeatability** | Standardized instructions ensure consistent execution across invocations |
| **Composability** | Skills can reference and build upon each other for complex workflows |
| **Discoverability** | Automatic detection via conventional directory paths or manual loading |
| **Self-Documentation** | Each skill contains metadata, instructions, examples, and use cases in one file |

Skills range from simple utilities (converting documents) to complex integrations (Notion MCP skills requiring external API access). The repository organizes skills into 10+ categories covering development, business, creative, and productivity domains.

**Sources:**[README.md 49-51](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L49-L51)[README.md 112-201](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L112-L201)

* * *

## The SKILL.md Format

### File Structure

Every skill centers on a required `SKILL.md` file following this standardized structure:

**Diagram: SKILL.md Anatomy**

**Sources:**[README.md 61-88](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L61-L88)

### Template Breakdown

`---name: my-skill-namedescription: A clear description of what this skill does and when to use it.---# My Skill NameDetailed description of the skill's purpose and capabilities.## When to Use This Skill- Use case 1- Use case 2- Use case 3## Instructions[Detailed instructions for LLMs on how to execute this skill]## Examples[Real-world examples showing the skill in action]`
| Section | Purpose | Required |
| --- | --- | --- |
| **Frontmatter** | Machine-readable metadata (YAML) | Yes |
| **Title** | Human-readable skill name | Yes |
| **Description** | Explains skill purpose and capabilities | Yes |
| **When to Use** | Defines appropriate usage contexts | Recommended |
| **Instructions** | Step-by-step workflow for LLM to follow | Yes |
| **Examples** | Demonstrates skill in action with real scenarios | Yes |

The instructions section is written **for the LLM**, not end users. It should include error handling, edge cases, prerequisites, and expected outputs.

**Sources:**[README.md 61-95](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L61-L95)

* * *

## Platform Integration Architecture

### Native vs Manual Integration

The repository supports two distinct integration models based on platform capabilities:

**Diagram: Platform Integration Patterns**

**Sources:**[README.md 99-108](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L99-L108)[README.md 204-250](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L204-L250)

### Platform Comparison

| Platform | Integration Method | Discovery | Invocation |
| --- | --- | --- | --- |
| **Claude Code** | Auto-discovery from `.claude/skills/` or `~/.claude/skills/` | Automatic | Natural language |
| **Claude Desktop** | ZIP upload via Settings → Capabilities → Skills | Manual upload | Natural language |
| **Codex CLI** | Reference SKILL.md in prompts | Manual | Prompt-based |
| **Gemini CLI** | Use `@` symbol to attach SKILL.md files | Manual | Prompt-based |
| **OpenCode** | Place in `skills/` folder, ask to read | Manual | Prompt-based |
| **Qwen Code** | Place in `skills/` folder, reference in prompts | Manual | Prompt-based |

**Claude platforms** provide first-class support with automatic skill loading and native execution. **Other platforms** require users to manually reference skill instructions, effectively using skills as structured prompt templates.

**Sources:**[README.md 204-250](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L204-L250)

* * *

## Skill Discovery Mechanisms

### Directory-Based Discovery (Claude Code)

Claude Code automatically discovers skills from two conventional locations:

**Diagram: Claude Code Discovery Paths**

**Sources:**[README.md 55-60](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L55-L60)[README.md 99-103](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L99-L103)[README.md 206-211](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L206-L211)

#### Discovery Priority

1.   **Project-level** (`.claude/skills/`): Highest priority, project-specific skills
2.   **User-level** (`~/.claude/skills/`): Global skills available across all projects

Each directory can contain multiple skill folders, with each folder containing a `SKILL.md` file and optional supporting files.

### Manual Loading Methods

For platforms without auto-discovery:

| Method | Platforms | Process |
| --- | --- | --- |
| **ZIP Upload** | Claude Desktop | Settings → Capabilities → Skills → Upload skill |
| **File Attachment** | Gemini CLI | Use `@` symbol to attach SKILL.md: `@path/to/SKILL.md` |
| **Directory Reference** | OpenCode, Qwen Code | Place in `skills/` folder, ask LLM to read it |
| **Prompt Inclusion** | All platforms | Copy/paste SKILL.md content into prompt |

**Sources:**[README.md 99-108](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L99-L108)[README.md 220-250](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L220-L250)

* * *

## Repository Organization

### Skill Categories

The repository organizes skills into a hierarchical taxonomy:

**Diagram: Repository Structure**

**Sources:**[README.md 112-201](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L112-L201)

### Category Descriptions

| Category | Skill Count | Description |
| --- | --- | --- |
| **MCP Integration Skills** | 4 | Require Model Context Protocol for external API integration (primarily Notion) |
| **Document Processing** | 5+ | Handle office formats (docx, pdf, pptx, xlsx) and conversions |
| **Development & Code Tools** | 15+ | Support software development workflows, testing, and automation |
| **Data & Analysis** | 3+ | Database queries, CSV analysis, root cause tracing |
| **Business & Marketing** | 5+ | Brand guidelines, lead research, competitive analysis |
| **Communication & Writing** | 5+ | Content creation, meeting analysis, article extraction |
| **Creative & Media** | 6+ | Image generation, video processing, GIF creation |
| **Productivity** | 5+ | File organization, invoice management, task planning |
| **Collaboration & PM** | 3+ | Git operations, code review, test management |
| **Security & Systems** | 4+ | Forensics, threat hunting, secure deletion |

**Sources:**[README.md 112-201](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L112-L201)

* * *

## Skill Lifecycle

### Creation to Execution Flow

**Diagram: Complete Skill Lifecycle**

**Sources:**[README.md 253-269](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L253-L269)

### Lifecycle Phases

#### 1. Creation Phase

Developers create skills based on real-world use cases, following the standardized template and testing across multiple platforms to ensure compatibility.

Key steps:

*   Validate use case necessity
*   Check for duplicate skills in repository
*   Follow SKILL.md template structure ([README.md 61-88](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L61-L88))
*   Add optional resources and helper scripts
*   Test on Claude Code, Claude Desktop, and ideally other platforms

#### 2. Distribution Phase

Skills are submitted to the repository via pull requests, reviewed for quality and completeness, then merged and published for community access.

Quality standards:

*   Based on real, practical use cases
*   Clear, unambiguous instructions for LLMs
*   Comprehensive examples with expected outputs
*   Cross-platform compatibility tested
*   Proper documentation and metadata

**Sources:**[README.md 253-269](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L253-L269)

#### 3. Adoption Phase

Users discover skills through the repository, load them into their preferred platforms using platform-specific methods, and make them available for invocation.

Discovery channels:

*   Repository README skill catalog
*   Anthropic Skills Marketplace
*   Community forums and discussions
*   Direct GitHub browsing

#### 4. Execution Phase

Once loaded, users invoke skills through natural language requests. The LLM matches the request to the appropriate skill, processes the skill's instructions, and executes the workflow.

Example invocation:

```
"Use the Webapp Testing skill to validate the checkout flow and generate report.md"
```

The LLM reads the skill's instructions section and follows the defined workflow to accomplish the task.

**Sources:**[README.md 99-108](https://github.com/cwinux/awesome-llm-skills/blob/d62d6510/README.md?plain=1#L99-L108)

* * *

## Supporting Infrastructure

### Documentation Resources


Title: The power of the Unix philosophy for LLM agentic tools

URL Source: http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools

Published Time: 2025-07-11T00:00:00+01:00

Markdown Content:
July 11, 2025 5 minute read

I was demonstrating Claude Code to a colleague the other day - I was working on an ASP.Net Core C# service, using Claude within the JetBrains Rider IDE. And my colleague said “it uses a lot of bash commands like `find` - why doesn’t it hook into the IDE to understand the structure?”

I was a bit surprised by this - I quite like the way it uses small simple commands. Musing about it afterwards, I realised that this is actually an example of the [Unix philosophy](https://en.wikipedia.org/wiki/Unix_philosophy) - “write programs that do one thing and do it well”.

I am already someone who loves diving into the command-line, I have a string of handy tools I use all the time - [jq](https://jqlang.github.io/jq/), [dua](https://github.com/Byron/dua-cli), [ripgrep](https://github.com/BurntSushi/ripgrep), [pbcopy and pbpaste](https://osxdaily.com/2007/03/05/manipulating-the-clipboard-from-the-command-line/), plus all the standard shell tools like find, grep etc - I was already enjoying this aspect of using LLM-based tools; they can be easily trained to use the tools I use already.

But I realise that this also reflects a philosophical difference between different software engineering communities. There are people who love lots of small unix-style tools, who live in the terminal or at least fall back to terminal commands regularly[1](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fn:1) - but there are also people who love their IDEs, their smart powerful tooling. It reminds me somewhat of the famous essay [the Cathedral and the Bazaar](http://www.catb.org/~esr/writings/cathedral-bazaar/cathedral-bazaar/) from way back in 1998.

A pertinent quote:

> Linus Torvalds’s style of development—release early and often, delegate everything you can, be open to the point of promiscuity—came as a surprise. No quiet, reverent cathedral-building here—rather, the Linux community seemed to resemble a great babbling bazaar of differing agendas and approaches … out of which a coherent and stable system could seemingly emerge only by a succession of miracles.

Sounds a bit familiar.[2](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fn:2)

Anyway - my colleague seemed to be surprised that the LLM wasn’t embracing the large, complicated, sophisticated modelling that a tool like Rider does - in fact up to now you _needed_ a tool like Rider to understand complex ecosystems like ASP.Net.

Whereas I quite like that it _doesn’t have to_ - it uses the Unix philosophy - text-based input and output (which language models naturally work well with), small fast stand-alone tools, that do one thing and one thing well. And despite the continued need for powerful IDEs, the world has shifted - even Cathedrals like ASP.Net now supply quite good command-line tools like `dotnet` for building, formatting, linting, and testing, with an LLM-friendly text interface. With all these tools, plus the ability to iterate over solutions and use trial-and-error to course correct, LLM-based tools do a quite good job of what previously needed a huge complex IDE.

Often Claude Code does a _better_ job than the smart IDEs for a lot of refactorings. I remember when refactoring IDEs first appeared, and they were amazing - I could say “extract these lines into a function” and it just worked. But now I can say to Claude “we are doing this repetitive pattern in our tests - can you change it to test against an array using Fluent Assertions instead?” and it turns:

```
getBusinessResponse.People.Count.Should().Be(2);
getBusinessResponse.People.Should().Contain(p => p.Id == newPersonResponse.Id);
getBusinessResponse.People.Should().Contain(p => p.Id == personResponse1.Id);
```

into:

```
getBusinessResponse.People.Select(p => p.Id)
  .Should().BeEquivalentTo(
    [newPersonResponse.Id, personResponse1.Id]);
```

and then it can find the equivalent pattern through all the tests, and do a good job of fixing them all.[3](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fn:3)

Claude Code itself also follows this philosophy - instead of being tightly coupled to an IDE, it runs in a terminal, with a text interface, and they have plugins for various IDEs to provide a smarter user interface - using the editor’s context and UI elements for changes. But basically it’s a text app - which must keep their complexity much lower than the competitors who are building their tools tightly coupled to particular editors.

Another example - my personal music collection is stored as mp3 files indexed and served by [MPD](https://www.musicpd.org/), the Music Player Daemon. It used to be in the Cathedral-like iTunes, but as Apple enshittified their apps, and my venerable iPod died (many years ago) I moved to MPD for storage, and other tools for UIs - and now this fits well with LLM tools. It has a command-line interface in [mpc](https://www.musicpd.org/clients/mpc/), I’m already using this to play music in Obsidian - see [my previous blog post](https://blog.korny.info/2024/09/06/custom-mac-uri-schemes-obsidian). So it’d be easy to call this from an LLM - or wrap it in an MCP service for a home-grown Siri or Alexa like music player.

And a third example - this blog is written using [Jekyll](https://jekyllrb.com/), which means it’s just markdown text. LLMs _love_ working with markdown. I don’t use LLMs to write the text[4](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fn:4) but I can say “please turn the word Jekyll into a link” and save a lot of annoying toil. An LLM would be much harder to integrate into a heavyweight Gui blog editor like Wix.

* * *

Anyway I digress. Tired brain tends to ramble. Back to my main thought - LLM code augmentation tools work best where they, and their users, embrace Unix-philosophy tools - multiple small tools that do one thing each, that interact with simple text-based formats.

I can see this being a bit of a struggle, and a culture clash, for people who love the Cathedral model - big complex clever systems. Often these are more powerful, more robust, more carefully engineered, and safer than the Bazaar of small independent tools. But I think LLMs are tipping the balance further to where the smaller tools, despite the risks and chaos, are dramatically more productive.

We just need to make sure we keep on top of the risks and chaos, and don’t drown in a world of technical debt and AI slop.

1.   I’m not a terminal purist - I don’t use vim, I still like GUIs for code editing, graphical tree widgets, visualisations…[↩](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fnref:1)

2.   I had a longer digression here but removed it as it went too far off piste! I encourage people to read the essay, it’s suprisingly relevant still[↩](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fnref:2)

3.   It’s non-deterministic, you have to check it for hallucinations, but they are pretty rare on simple changes like this. And it will run the tests after every change, and iterate if something goes wrong.[↩](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fnref:3)

4.   I’m fine with expressing my ideas in writing, though I tend to digress too much![↩](http://blog.korny.info/2025/07/11/the-power-of-the-unix-philosophy-for-llm-agentic-tools#fnref:4)


Title: LLM Wiki Skill: Build a Second Brain With Claude Code and Obsidian

URL Source: http://alirezarezvani.medium.com/llm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1

Published Time: 2026-04-12T11:54:14Z

Markdown Content:
# LLM Wiki Skill: Build a Second Brain With Claude Code and Obsidian | Medium

[Sitemap](http://alirezarezvani.medium.com/sitemap/sitemap.xml)

[Open in app](https://play.google.com/store/apps/details?id=com.medium.reader&referrer=utm_source%3DmobileNavBar&source=post_page---top_nav_layout_nav-----------------------------------------)

Sign up

[Sign in](https://medium.com/m/signin?operation=login&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=post_page---top_nav_layout_nav-----------------------global_nav------------------)

[](https://medium.com/?source=post_page---top_nav_layout_nav-----------------------------------------)

Get app

[Write](https://medium.com/m/signin?operation=register&redirect=https%3A%2F%2Fmedium.com%2Fnew-story&source=---top_nav_layout_nav-----------------------new_post_topnav------------------)

[Search](https://medium.com/search?source=post_page---top_nav_layout_nav-----------------------------------------)

Sign up

[Sign in](https://medium.com/m/signin?operation=login&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=post_page---top_nav_layout_nav-----------------------global_nav------------------)

![Image 3](https://miro.medium.com/v2/resize:fill:64:64/1*dmbNkD5D-u45r44go_cf0g.png)

Member-only story

# LLM Wiki Skill: Build a Second Brain With Claude Code and Obsidian

## _Karpathy’s wiki pattern compiles knowledge instead of retrieving it — here is the complete Claude Code skill I built to make it work in production_

[![Image 4: Reza Rezvani](https://miro.medium.com/v2/resize:fill:64:64/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---byline--2282752758c1---------------------------------------)

[Reza Rezvani](http://alirezarezvani.medium.com/?source=post_page---byline--2282752758c1---------------------------------------)

Follow

16 min read

·

Apr 12, 2026

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2F2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&user=Reza+Rezvani&userId=b66488794c91&source=---header_actions--2282752758c1---------------------clap_footer------------------)

214

3

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fbookmark%2Fp%2F2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---header_actions--2282752758c1---------------------bookmark_footer------------------)

[Listen](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2Fplans%3Fdimension%3Dpost_audio_button%26postId%3D2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---header_actions--2282752758c1---------------------post_audio_button------------------)

Share

Three months of architecture decisions lived in 14 teams threads, two Notion databases, a shared Google Doc that nobody updated after January, and my own memory. Last Tuesday a new engineer asked why we chose event-driven messaging over REST for our notification service. I knew the answer.

I had debated it in a meeting, sketched it on a whiteboard, and defended it in a pull request comment. But finding the actual reasoning took twenty-five minutes of scrolling.

Press enter or click to view image in full size

![Image 5: Illustration showing documents being organized into a wiki by a robot character](https://miro.medium.com/v2/resize:fit:700/1*u4Tl3I6t2MqUJOilxVqWkg.png)

**LLM Wiki Skill:**Build a Second Brain | Image: Gemini Pro © Alireza Rezvani

**_Note:_**_AI tools were used during the editing process. The testing, technical analysis, and recommendations are based on my own experience._

That same week, Andrej Karpathy published a gist titled _“LLM Wiki”_ — 5,000 stars in four days, nearly 3,000 forks. One sentence in the gist reframed the entire problem: the shift is from retrieval to compilation. Not _“find the document that answers this query.”_

**Instead:**_“build and maintain a persistent, cross-referenced knowledge base that already contains the synthesized answer.”_

## Create an account to read the full story.

The author made this story available to Medium members only.

If you’re new to Medium, create a new account to read this story on us.

[Continue in app](https://play.google.com/store/apps/details?id=com.medium.reader&referrer=utm_source%3Dregwall&source=-----2282752758c1---------------------post_regwall------------------)

Or, continue in mobile web

[Sign up with Google](http://medium.com/m/connect/google?state=google-%7Chttps%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1%3Fsource%3D-----2282752758c1---------------------post_regwall------------------%26skipOnboarding%3D1%7Cregister%7Cremember_me&source=-----2282752758c1---------------------post_regwall------------------)

[Sign up with Facebook](http://medium.com/m/connect/facebook?state=facebook-%7Chttps%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1%3Fsource%3D-----2282752758c1---------------------post_regwall------------------%26skipOnboarding%3D1%7Cregister%7Cremember_me&source=-----2282752758c1---------------------post_regwall------------------)

Sign up with email

Already have an account? [Sign in](https://medium.com/m/signin?operation=login&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=-----2282752758c1---------------------post_regwall------------------)

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2F2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&user=Reza+Rezvani&userId=b66488794c91&source=---footer_actions--2282752758c1---------------------clap_footer------------------)

214

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2F2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&user=Reza+Rezvani&userId=b66488794c91&source=---footer_actions--2282752758c1---------------------clap_footer------------------)

214

3

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fbookmark%2Fp%2F2282752758c1&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---footer_actions--2282752758c1---------------------bookmark_footer------------------)

[![Image 6: Reza Rezvani](https://miro.medium.com/v2/resize:fill:96:96/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---post_author_info--2282752758c1---------------------------------------)

[![Image 7: Reza Rezvani](https://miro.medium.com/v2/resize:fill:128:128/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---post_author_info--2282752758c1---------------------------------------)

Follow

## [Written by Reza Rezvani](http://alirezarezvani.medium.com/?source=post_page---post_author_info--2282752758c1---------------------------------------)

[6.9K followers](http://alirezarezvani.medium.com/followers?source=post_page---post_author_info--2282752758c1---------------------------------------)

·[81 following](http://alirezarezvani.medium.com/following?source=post_page---post_author_info--2282752758c1---------------------------------------)

CTO & AI builder based in Berlin. Writing about Claude Code, agentic workflows, and shipping real products with AI. 20+ years of turning ideas into products.

Follow

## Responses (3)

[](https://policy.medium.com/medium-rules-30e5502c4eb4?source=post_page---post_responses--2282752758c1---------------------------------------)

![Image 8](https://miro.medium.com/v2/resize:fill:32:32/1*dmbNkD5D-u45r44go_cf0g.png)

Write a response

[What are your thoughts?](https://medium.com/m/signin?operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---post_responses--2282752758c1---------------------respond_sidebar------------------)

Cancel

Respond

[![Image 9: Reza Rezvani](https://miro.medium.com/v2/resize:fill:32:32/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---post_responses--2282752758c1----0-----------------------------------)

[Reza Rezvani](http://alirezarezvani.medium.com/?source=post_page---post_responses--2282752758c1----0-----------------------------------)

Author

[Apr 12](http://alirezarezvani.medium.com/the-skill-files-are-available-in-my-claude-skills-repo-on-github-7a25422996ec?source=post_page---post_responses--2282752758c1----0-----------------------------------)

The skill files are available in my claude-skills repo on GitHub. The part that surprised me most was how fast the wiki becomes useful — after just 5-6 sources, the cross-references start connecting things you did not realize were related.

If you are…more

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2F7a25422996ec&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fthe-skill-files-are-available-in-my-claude-skills-repo-on-github-7a25422996ec&user=Reza+Rezvani&userId=b66488794c91&source=---post_responses--7a25422996ec----0-----------------respond_sidebar------------------)

4

Reply

[![Image 10: Kamrun Nahar](https://miro.medium.com/v2/resize:fill:32:32/1*QOR69Qng-Cp0MvWWxxKRiQ.jpeg)](https://iknahar.medium.com/?source=post_page---post_responses--2282752758c1----1-----------------------------------)

[Kamrun Nahar she/her](https://iknahar.medium.com/?source=post_page---post_responses--2282752758c1----1-----------------------------------)

[3 days ago](https://iknahar.medium.com/following-you-after-this-one-c71eb8a5e5cc?source=post_page---post_responses--2282752758c1----1-----------------------------------)

following you after this one ✨...

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2Fc71eb8a5e5cc&operation=register&redirect=https%3A%2F%2Fiknahar.medium.com%2Ffollowing-you-after-this-one-c71eb8a5e5cc&user=Kamrun+Nahar&userId=df89b702f339&source=---post_responses--c71eb8a5e5cc----1-----------------respond_sidebar------------------)

3

1 reply

Reply

[![Image 11: Sven Cammerer](https://miro.medium.com/v2/resize:fill:32:32/0*9zZ3cX8unYiBtAti)](https://medium.com/@sven.cammerer?source=post_page---post_responses--2282752758c1----2-----------------------------------)

[Sven Cammerer](https://medium.com/@sven.cammerer?source=post_page---post_responses--2282752758c1----2-----------------------------------)

[4 days ago](https://medium.com/@sven.cammerer/thanks-for-building-the-skill-i-will-definitely-try-it-out-this-article-made-me-follow-you-b4c788cb20d1?source=post_page---post_responses--2282752758c1----2-----------------------------------)

Thanks for building the skill :-) I will definitely try it out! This article made me follow you!

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fvote%2Fp%2Fb4c788cb20d1&operation=register&redirect=https%3A%2F%2Fmedium.com%2F%40sven.cammerer%2Fthanks-for-building-the-skill-i-will-definitely-try-it-out-this-article-made-me-follow-you-b4c788cb20d1&user=Sven+Cammerer&userId=c0da4eda2e45&source=---post_responses--b4c788cb20d1----2-----------------respond_sidebar------------------)

1

1 reply

Reply

## More from Reza Rezvani

![Image 12: Boris Cherny’s Claude Code Tips Are Now a Skill. Here Is What the Complete Collection Reveals.](https://miro.medium.com/v2/resize:fit:679/format:webp/1*eHlu1ib-JA6lb60Yj4R-Pw.png)

[![Image 13: Reza Rezvani](https://miro.medium.com/v2/resize:fill:20:20/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---author_recirc--2282752758c1----0---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[Reza Rezvani](http://alirezarezvani.medium.com/?source=post_page---author_recirc--2282752758c1----0---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

## [Boris Cherny’s Claude Code Tips Are Now a Skill. Here Is What the Complete Collection Reveals.](http://alirezarezvani.medium.com/boris-chernys-claude-code-tips-are-now-a-skill-here-is-what-the-complete-collection-reveals-b410a942636b?source=post_page---author_recirc--2282752758c1----0---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

Mar 22

[4](http://alirezarezvani.medium.com/boris-chernys-claude-code-tips-are-now-a-skill-here-is-what-the-complete-collection-reveals-b410a942636b?source=post_page---author_recirc--2282752758c1----0---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[](https://medium.com/m/signin?operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---author_recirc--2282752758c1----0-----------------explicit_signal----fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fbookmark%2Fp%2Fb410a942636b&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fboris-chernys-claude-code-tips-are-now-a-skill-here-is-what-the-complete-collection-reveals-b410a942636b&source=---author_recirc--2282752758c1----0-----------------bookmark_preview----fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

![Image 14: Claude Code agent architecture visualization showing 10 interconnected build steps flowing from a single Markdown file to a full multi-agent production system](https://miro.medium.com/v2/resize:fit:679/format:webp/1*lE8alsLW7zU0bpvrVzhqig.png)

[![Image 15: Reza Rezvani](https://miro.medium.com/v2/resize:fill:20:20/1*jDxVaEgUePd76Bw8xJrr2g.png)](http://alirezarezvani.medium.com/?source=post_page---author_recirc--2282752758c1----1---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[Reza Rezvani](http://alirezarezvani.medium.com/?source=post_page---author_recirc--2282752758c1----1---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

## [How to Build Claude Code Agents from Scratch — The 10-Step Framework I Actually Use in Production ### No LangChain. No CrewAI. Just Markdown files with YAML frontmatter — and the production patterns that make them work.](http://alirezarezvani.medium.com/how-to-build-claude-code-agents-from-scratch-the-10-step-framework-i-actually-use-in-production-6f6a358f4f8c?source=post_page---author_recirc--2282752758c1----1---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

Mar 30

[10](http://alirezarezvani.medium.com/how-to-build-claude-code-agents-from-scratch-the-10-step-framework-i-actually-use-in-production-6f6a358f4f8c?source=post_page---author_recirc--2282752758c1----1---------------------fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[](https://medium.com/m/signin?operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fllm-wiki-skill-build-a-second-brain-with-claude-code-and-obsidian-2282752758c1&source=---author_recirc--2282752758c1----1-----------------explicit_signal----fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)

[](https://medium.com/m/signin?actionUrl=https%3A%2F%2Fmedium.com%2F_%2Fbookmark%2Fp%2F6f6a358f4f8c&operation=register&redirect=https%3A%2F%2Falirezarezvani.medium.com%2Fhow-to-build-claude-code-agents-from-scratch-the-10-step-framework-i-actually-use-in-production-6f6a358f4f8c&source=---author_recirc--2282752758c1----1-----------------bookmark_preview----fe70b749_bcae_41ae_8c81_e70b97cfc5ad--------------)


Sí, hay **dos capas distintas**. Y la diferencia real importa.

## 1) Skill = paquete de contexto / instrucciones
Un `SKILL.md` sirve para:
- decir **qué hace** algo
- **cuándo usarlo**
- cómo invocarlo
- qué archivos auxiliares hay

Eso es **descubribilidad + estandarización + portabilidad**.
La idea que empuja bastante la comunidad de skills es: *“compilar conocimiento”* en un formato reusable.

## 2) Tool = ejecución concreta
Los `browser-*` son la parte operativa:
- `browser-start`
- `browser-nav`
- `browser-eval`
- `browser-screenshot`
- `browser-pick`
- `browser-cookies`
- `browser-content`

Eso ya es **Unix philosophy**:
- una cosa por herramienta
- salida simple
- composable
- fácil de encadenar
- fácil de persistir a archivo si hace falta

## Lo que marca diferencia de verdad
No es “skills vs tools”.
Es esto:

- **skills** = cómo le enseñás al agente a elegir y usar cosas
- **tools** = las cosas que ejecuta de verdad

Si mezclás todo en una sola bola grande, el agente pierde claridad y consume contexto al pedo.

## Lo que opina Mario Zechner
Su postura es bastante clara:
- **MCP grande y monolítico = mala idea** para muchos casos
- los servers con muchos tools y descripciones largas **gastan contexto**
- los outputs que vuelven al agente y vuelven a salir **rompen composabilidad**
- prefiere **bash + scripts chicos + código**
- para browser, quiere un set mínimo y reusable

O sea:
**Mario no está contra skills**. Está contra el **peso innecesario**.
Su browser-tools es justamente un ejemplo de:
- un skill chico
- con scripts chicos
- con una README/SKILL.md que le dice al agente cómo usarlos

## Lo que dice otra gente
Hay dos corrientes fuertes:

### A. Skills como formato reutilizable
La de varios repos y autores de skills:
- `SKILL.md` como unidad portable
- frontmatter + instrucciones + ejemplos
- descubierta automática o manual
- pensada para que el modelo “cargue” comportamiento específico sin rearmarlo cada vez

### B. Unix tools para agentes
La de la gente más terminal / infra:
- herramientas chicas
- textos simples
- pipes / archivos / stdout
- menos magia, más composición
- mejor para agentes porque el LLM entiende texto y diffs mejor que UIs gigantes

Korny lo dice bastante bien: hay una diferencia cultural real entre el mundo “terminal/unix” y el mundo “cathedral/IDE”. Los LLM están inclinando la balanza hacia el lado Unix.

## Mi lectura práctica
Para vos, la regla útil es:

- **1 skill por dominio de trabajo**
- **muchos tools chicos adentro**
- no un skill por cada script
- no un MCP monolítico con 30 herramientas si alcanza con 7
- el skill tiene que **orientar**, no ahogar

## En browser tools, la estructura correcta es esta
- `browser-tools` = skill
- `browser-*.js` = herramientas
- `SKILL.md` = frontmatter + guía de uso
- el agente lee eso y después ejecuta scripts chicos

Eso es una mezcla de ambas filosofías, y está bien así.

Si querés, te hago una **propuesta concreta de organización para tus skills**:
- qué va en `SKILL.md`
- qué va en scripts
- qué no debería ser skill
- y cómo evitar sobrecargar contexto.


Entonces, pasemos este skill de browser al lugar oficial para los skills. y saquemos referencia en AGENTS


find ~/.pi -maxdepth 3 -type d | sed -n '1,200p'

cat ~/.pi/agent/settings.json 2>/dev/null | sed -n '1,220p'

grep -RIn 'skills' ~/.pi /mnt/rpi/pi-config 2>/dev/null | head -120


/home/sebas/.pi
/home/sebas/.pi/agent
/home/sebas/.pi/agent/bin
/home/sebas/.pi/agent/sessions
/home/sebas/.pi/agent/sessions/--mnt-rpi--
/home/sebas/.pi/agent/themes
/home/sebas/.pi/agent/extensions
/home/sebas/.pi/agent/extensions/subagent