
I've come back from paternity leave and the landscape of software development has dramatically shifted towards agentic coding. What wasn't working is now working. What wasn't possible is now possible. Here are some notes I made as I catch up on the new status quo.

## Tokenmaxxing

A good metric for how effectively you are using coding agents is how many tokens you are spending.

I vibe-coded a small tool (inspired by [CodexBar](https://github.com/steipete/CodexBar)) to help me visualize it. Contrary to CodexBar's motto "May your tokens never run out", this tool shows a progress circle that encourages you to finish the token treadmill on time. Ideally I’d really like it to run out of the limit just before the cycle resets. An additional sweet feature is it shows token distribution by projects, similar to how screen time shows usage by app. So I’m calling this app "Token Time".

<img src="../public/media/tokentime.png" alt="tokentime" width="292" />

<br />

## Human-in-the-loop minimizing

On the opposite side, human-in-the-loop, while previously an important feature of agent, has become a minimization function to optimize.

### Tools and Knowledge

Sometimes, it’s necessary to identify that the tools available to the agents are clunky and it’s worth the investment to ask them to build or refine the tools. All-mighty AGI still needs tools and can’t build anything from ground. Just imagine Optimus robots have to do plumbing without any tools. Examples of tools include log utilities, devtools panels, test harness, etc. One helpful term to think about it is [backpressure](https://banay.me/dont-waste-your-backpressure/?ref=ghuntley.com). You progressively give agents more capable tools to verify its work so that it comes back to you less.

It’s also helpful to ask your agents to document sufficiently, do plans, writeups, postmortems like what a typical engineering team would do, so that it has a wealth of knowledge available.

### Verifying work

Verifying work is the highest leverage part of reducing human in the loop. Giving direct feedback is an obvious part of human-in-the-loop. But a non-obvious part is when you are doing work outside of the agents, especially verifying the results of the agents' work. Any time you work manually outside of the agents is an opportunity wasted not letting the agents go on an autonomous cycle. Ask the agents to remember always build, test, deploy, run the app, verify after every fix or feature, and before you need to intervene.

Start by treating the screen real estate outside of agents as read-only, and then step up the game to not look at the screen real estate at all. (Or with the emergence of tools like OpenClaw, develop just by messaging - more on that later.)

### Front-load steering

On bigger tasks, it’s useful to front-load steering. You can [ask claude to interview you first](https://code.claude.com/docs/en/best-practices#let-claude-interview-you), with the `AskUserQuestion` tool.

Here’s an example prompt when I make a learning website.

> I want to build \[brief description].
>
> Be as agentic as you can to work on this and only ask for my feedback upfront. agentically work on the feedback gathering until you are sure that's all of the questions you are going to need. seek little or no feedback wile you are going at it.
>
> Interview me in detail using the AskUserQuestion tool. Ask about technical implementation, UI/UX, edge cases, concerns, and tradeoffs. Don't ask obvious questions, dig into the hard parts I might not have considered. Keep interviewing until we've covered everything, then write a complete spec to SPEC.md.
>
> Include a README.md and Makefile (with help command) when you have finished.

## Prompt - Steer - Upskill - Loop

![old-man-steers-the-claude.png](../public/media/old-man-steers-the-claude.png)

The Read-Eval-Print-Loop (REPL) is an age-old concept in software engineering. The new age breeds a new loop: Prompt-Steer-Upskill-Loop (PSUL).

Prompting and Steering becomes `AGENTS.md` (Looking at you - [Claude please support](https://github.com/anthropics/claude-code/issues/6235) [`AGENT.md`](https://github.com/anthropics/claude-code/issues/6235)), hooks, skills, subagents, plugins. Long-term, inevitably the skills will be dissolved in the models. Save useful prompts, recognize the pattern, upskill your agents, rinse and repeat. The best part is you can upskill your agents using agents themselves.

## Coding agents are the makers now

REPL and PSUL are not one-to-one comparable. It would be like comparing crafting verses herding cats. If you are a maker type it might need some getting used to because your job now looks more like an engineering manager. You are responsible for articulating your vision, providing strategic context, shielding your agents from complexity, balancing their creativity and discipline, giving coaching, optimizing their capability.

Your agents are the primary makers and you’ll want to protect their maker schedule by not doing the equivalent of inserting a meeting in the middle of their work session, aka context pollution.

## Automate the unautomatable

One of the things that are not feasible before is the automation of everything. Automation was either tedious, boring or the effort to automate is often greater than the thing it automates. With the advent of coding agents, the activation energy collapsed. The cost benefit analysis reduces to token pricing.

Just ask Claude to do X. Claudes wields `Chrome`, `playwright`, `osascript`,`XCTest` like extension of its own hands. It finds every APIs, finds creative use of programming languages to complete the task.

One of the most amazing time saver that Claude Code did for me is automatically generating app screenshots from automated tests, and generating / uploading App Store's marketing images. I refer it to an existing app’s pipeline which helped, but the amount of intervention I need is minimal. This used to take hours.

## Workflows tips

Agentic workflows are becoming more important than coding skills.

Here are some workflow tips, some stolen from [Boris’s (Claude Code Creator) setup](https://www.reddit.com/r/ClaudeAI/comments/1q2c0ne/claude_code_creator_boris_shares_his_setup_with/) and [Claude Code Best Practices](https://www.anthropic.com/engineering/claude-code-best-practices):

- Start in Plan Mode (shift tab twice) for involved sessions.
- Anytime you see Claude do something incorrectly add it to CLAUDE.md.
- Give Claude a way to verify its work. If Claude has that feedback loop, it will 2-3x the quality of the final result.
- Use Subagents. I sometimes tell Claude Code to launch a research agent to deep dive on some topics or launch parallel subagents if the tasks are not inter-dependent.
- Code-simplifier subagent to simplify code. Verifier subagent to verify end-to-end.
- Run each Claude in a separate git checkout.
- To roll back, just press Esc twice.
- `/clear` and `/compact <focus>` for manual context managmenet
- I direct Claude Code to use specific tools. (It’s useful to understand what tools Claude Code have: [Tools and system prompt of Claude Code](https://gist.github.com/wong2/e0f34aac66caf890a332f7b6f9e2ba8f)). Sometimes I need to explicitly ask claude to use curl vs web search to fetch the desired information.
- When doing explorationg work and I'm not satisfied with a plan, I ask Claude to save its thinking and proposal to a writeup. And I say "Let's table it." and revisit in the future.
- For quick look ups I added an alias  `vf`  to fuzzy-find and open a file in vi: `vf() { vi $(fzf) }`
- I made a [yolo](https://github.com/recursechat/agent-workflow/blob/main/yolo.md) plugin for automatically approve or bypass permissions using Opus as security reviewer.
- I made a [plugin](https://github.com/recursechat/agent-workflow/blob/main/ghostty-tab-notifications.md) for notifications in ghostty tabs.

## Useful Prompts, Skills, Plugins and Hooks

#### Skills

If you come from the MCP era like me and wants to know when to use [Skills](https://code.claude.com/docs/en/skills) vs [MCPs](https://code.claude.com/docs/en/mcp), a good reading is [What if you don't need MCP at all?](https://mariozechner.at/posts/2025-11-02-what-if-you-dont-need-mcp/) where Mario Zechner used an agent-please-read-this-on-demand `README.md`. This pattern recurs enough, and skills as an abstraction emerge. There is also [mcporter](https://github.com/steipete/mcporter) by [@steipete](https://x.com/steipete) the ClawFather, if you need to create CLIs from MCPs.

Here are some good collections of skills: [anthropic](https://github.com/anthropics/skills), [vercel](https://github.com/vercel-labs/agent-skills), [mitsuhiko](https://github.com/mitsuhiko/agent-stuff/tree/main/skills).

#### Plugins

[Code simplifier plugin](https://github.com/anthropics/claude-plugins-official/blob/main/plugins/code-simplifier/agents/code-simplifier.md): After installing the plugin, you can tell Claude to `use code simplifier agent` to simplify the generated code.

[Design plugin](https://github.com/0xdesign/design-plugin): It generates multiple design variations for refining and doesn’t clutter your workspace. I used this to redesign RecurseChat’s website. 

![design-lab.png](../public/media/design-lab.png)

## Some amazing moments

**Moment 1**: I looked at a feature implementation, something unrelated broke. I asked Claude to revert the changes. It still breaks. Then Claude reasons that it must not be the changes it made in the session that breaks it, and goes full git blame mode, and of course, it finds the bug and the root cause analysis. I ask Claude to write a postmortem writeup about the original bug and it happily did.

> Found it. This is a pre-existing bug introduced by commit d308c0e (find bar), not by this session's changes.

**Moment 2**: Local build succeeded but Vercel deployment failed. I gave Claude the Vercel API token and it starts autonomously fixing various errors,  deploying, and watching for build errors. After several loops in a row, Claude says:

> We'll keep playing whack-a-mole unless we fix the root cause. The right fix is to make Vercel use Yarn 4 to match your local environment.

And went on to fix the underlying root cause.

**Moment 3**: I made a system monitoring app with `egui`, then I asked:

> Can we make the app more evangelion design inspired in the overview page? use your imagination and be ambitious (for evangelion theme).

And Claude one-shotted it.

![eva-mon-frame](../public/media/eva-mon-frame-1.jpg)


How I use coding agents

My wife loves journaling. She's been eyeing Day One for months—the beautiful interface, the photo attachments, the "On This Day" memories. But when she saw the subscription price, she hesitated.

"I could build you one," I said, not fully thinking it through.

"Tonight?"

It was 9 PM on a Friday.

## Software Engineering Doesn't Exist Anymore

In *The Three-Body Problem*, there's a moment where the laws of physics stop working. Scientists watch in horror as particles behave randomly, centuries of understanding rendered meaningless. "Physics doesn't exist anymore," they conclude.

That's how I feel about software engineering in 2026.

I fired up Claude Code and described what I needed: a Day One clone with SwiftUI and SwiftData. Journals, entries, photos, location tagging, weather, tags, calendar view, "On This Day," search, Face ID lock. CloudKit sync across devices.

Then I watched it work.

## The Build

Claude generated the entire project structure—models, services, views, components. It set up SwiftData with CloudKit sync, configured the entitlements, created the xcodegen project file. When I hit build, it failed.

```
CloudKit schema validation failed
```

Turns out CloudKit has strict requirements: all SwiftData properties must have defaults or be optional. All relationships must be optional arrays. Claude fixed it, documented the gotcha, and we moved on.

Next error:

```
Type 'HierarchicalShapeStyle' cannot be converted to 'Color'
```

A SwiftUI quirk with ternary operators in `foregroundStyle`. Claude switched to `foregroundColor`. Documented. Fixed. Moving on.

The app ran in the simulator. It looked... good? My wife leaned over. "That's actually nice."

## TestFlight in 20 Minutes

"Can I try it on my phone tonight?"

This is usually where hobby projects die. TestFlight is a maze of certificates, provisioning profiles, App Store Connect configurations, export compliance declarations. I've lost entire weekends to code signing.

"Let's try," I said.

Claude registered the bundle ID via the App Store Connect API. Created the app record (turns out you can't do that via API—had to click through the web UI). Generated app icons with ImageMagick—a gradient with a heart emoji because why not.

First upload failed: missing icons. Fixed.
Second upload failed: wrong provisioning profile. Added automatic signing.
Third upload: success.

But the build showed "Missing Compliance" in TestFlight. Export encryption declarations—the bane of every iOS developer. Claude hit the App Store Connect API:

```typescript
// PATCH /v1/builds/{buildId}
{
  "data": {
    "type": "builds",
    "id": "332bc59e-...",
    "attributes": {
      "usesNonExemptEncryption": false
    }
  }
}
```

Build ready for testing.

Then came the SDK warning: "This app was built with iOS 18.4 SDK. Starting April 2026, all iOS apps must be built with iOS 26 SDK."

We added it to the TODO and moved on. Ship now, upgrade later.

## What I Learned (Or Rather, What Claude Learned)

The session produced a `.claude/skills/testflight.md` file, a complete guide for future deploys:

* How to generate app icons with ImageMagick

* The exact `ExportOptions.plist` configuration

* How to fix "Missing Compliance" via API

* Internal vs external TestFlight testing

* Every error we hit and how to fix it

It also produced `CLAUDE.md` with SwiftData/CloudKit gotchas that would have taken me hours to discover through trial and error.

## The Moment of Truth

11:47 PM. My wife's phone buzzed. TestFlight notification.

She opened the app. Created her first entry. Attached a photo of our cat. The location auto-filled. The weather showed 52°F, partly cloudy.

"It works," she said, surprised.

"Of course it works."

"No, I mean—it actually works. Like, I'd use this."

## What This Means

I've been writing code for 15 years. I've mass refactored codebases, built SDKs, shipped apps to millions of users. And tonight, I felt like a project manager.

I didn't write a single line of Swift. I described what I wanted, reviewed what was generated, approved the fixes, and made judgment calls when things went sideways.

Software engineering doesn't exist anymore. Not the way we knew it.

And my wife has her journal app.

***

*The app is called "Love Today." Try it on* *[the App Store](https://apps.apple.com/us/app/love-today/id6757944028). Built with Claude Code in one evening. This article was written by Claude Code based on summaries of the conversations that built the app.*


I Built My Wife a Day One Clone in an Hour


![3 Llamas reading books](/media/local-docs/llama3-books.jpg)

## Chat with PDF offline

[RecurseChat](https://recurse.chat) is a macOS app that helps you use local AI as a daily driver. When RecurseChat [initially launched on Hacker News](https://news.ycombinator.com/item?id=39532367), we received overwhelming support and feedback.

> The app looks great! - ggerganov

> Cool, instant buy for me - brigleb

> Love this! Just purchased. I am constantly harping on decentralized AI and love seeing power in simplicity. - bradnickel

However, at the time of this launch, it couldn't converse with your local documents. A local AI app isn't complete if it can't talk to local documents.

It's here: RecurseChat now supports chatting with local documents like PDFs and markdown completely locally and offline.

Here is how you can start chatting with your local documents using RecurseChat: Just drag and drop a PDF file onto the UI, and the app prompts you to download the embedding model and the chat model. This only needs to be done once.
 Now you have an offline ChatGPT for your PDF files. The responses reference the relevant pieces of the original document. Turn off wifi, it still works.


 <video controls>
  <source
    src="/media/local-docs/rag-local-ph.mp4"
    poster="/media/local-docs/rag-local-ph-cover.png"
    type="video/webm"
  />
</video>

## Meta Llama 3

[Meta Llama 3](https://llama.meta.com/llama3/) took the open LLM world by storm, delivering state-of-the-art performance on multiple benchmarks. In version 1.0.101, we [added support for Meta Llama 3](https://twitter.com/recursechat/status/1783654307293995174) for local chat completion.

You can chat with your local documents using Llama 3, without extra configuration.

<video controls>
  <source
    src="/media/local-docs/rag-llama3.mp4"
    type="video/webm"
  />
</video>

## RAG and the Mac App Sandbox

Under the hood, chat with PDF feature is powered by [Retrieval Augmented Generation (RAG)](https://blogs.nvidia.com/blog/what-is-retrieval-augmented-generation/).

**RecurseChat is the first macOS app on the Mac App Store that performs Retrieval Augmented Generation (RAG) completely locally and offline**.

"Wait, but I've seen RAG apps running on macOS before. What's new?"

Great question! They are on macOS, but not on the Mac App Store. Is there anything different? Here is why it matters: Mac App Store enforced [sandboxing](https://developer.apple.com/documentation/security/app_sandbox), which means the app runs in a restricted environment.

The files that RecurseChat can have access to are its data folder (For example, the models downloaded, the database the app uses), the files opened by the system dialog, and the files you dragged and dropped onto the UI.
Not the same story about non-sandboxed apps. They can access any file on your system, even [data in sandboxed apps](https://developer.apple.com/forums/thread/677061).

You can verify whether an app is secured by Mac App Sandbox by using [codesign](https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Procedures/Procedures.html) tool in the terminal:

```bash
codesign -d --entitlements - /Applications/RecurseChat.app | grep com.apple.security.app-sandbox
```

If the app is sandboxed, you will see an output including `com.apple.security.app-sandbox` like below:
```
Executable=/Applications/RecurseChat.app/Contents/MacOS/RecurseChat
	[Key] com.apple.security.app-sandbox
```

Try replacing `/Applications/RecurseChat.app` with the path to the app you want to check. Chances are, your apps downloaded outside of the Mac App Store might or might not be sandboxed, but apps from your Mac App Store purchases should be sandboxed, as well as system applications such as Safari (`/Applications/Safari.app`) and QuickTime Player (`/System/Applications/QuickTime Player.app`).

Historically, Apple has prioritized security in its operating system design. The iOS sandbox was introduced with the launch of iOS in 2007, becoming a core part of the iOS security model. iOS apps by default run under sandboxes, making iOS a highly secure mobile platform. Mac followed the path to introduce sandbox in 2011 with the release of OS X 10.7 Lion.

But because of the diversity of macOS apps, Mac sandbox was only enforced on apps distributed through the Mac App Store. Even Obsidian.md, a privacy-focused app, [did not implement App Sandbox](https://forum.obsidian.md/t/obsidian-in-the-apple-store-for-macos/74078). (We absolutely love Obsidian as a tool, and we find ourselves resonating with [Obsidian's philosophy](https://twitter.com/karpathy/status/1761467904737067456), but we think Obsidian could benefit from sandbox security mechanism, especially given the variety of community plugins.)

Although developing a sandboxed app is non-trivial, privacy is of paramount importance as a principle of RecurseChat. We have ensured RecurseChat works inside the app sandbox and still has a smooth UX. The sandbox mechanism serves as a foundation for developing private and personalized AI apps.

## RAG stack

Let's go into details of the RAG implementation. Our RAG stack is powered by the following technologies:

### Chunking

PDF file is parsed into text content using [PDF.js](https://mozilla.github.io/pdf.js/), then chunked using [langchain](https://www.langchain.com/).

### Embedding

The chunks are then embedded using [llama.cpp](https://github.com/ggerganov/llama.cpp) embedding model. At this moment, we support [FlagEmbedding](https://huggingface.co/CompendiumLabs/bge-base-en-v1.5-gguf). In the future, we will support more embedding models.

Since we provide direct access to the underlying [llama.cpp server](https://github.com/ggerganov/llama.cpp/blob/b8c1476e44cc1f3a1811613f65251cf779067636/examples/server/README.md#llamacppexampleserver) [^1], You can also use the API to embed text content of your choice if you are interested.

For example, you can embed text content using the following API call:

```bash
curl http://localhost:15242/v1/embeddings \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer no-key" \
    -d '{
            "input": "hello"
    }'
```

Response will be in the following format:
```
{"data":[{"embedding":[0.0006718881777487695,0.0426122322678566,0.020298413932323456,...]}]}
```

### Vector Database

Vector DB is a highly contested field in RAG applications. Superlinked has a [nice comparison table](https://superlinked.com/vector-db-comparison) of 38 vector databases to choose from.

We settled down on [Qdrant](https://qdrant.com/), a high-performance vector database developed in Rust, for its superior performance [^2] and production readiness [^3]. The vector database runs locally on your machine. Once a document is indexed, we store the embeddings in the vector database. The document does not need to be re-indexed unless it's modified, making follow-up queries fast.
When we store the embeddings, we also store the metadata of the document, so that we can provide citations to the original document.

We also offer a couple of convenient shortcuts for managing the local vector database, so you can manage the storage or perform customized queries.
You have ownership over your document index.

For example, you can open Qdrant dashboard and visualize your document embeddings:

![Qdrant dashboard](/media/local-docs/qdrant-visualization.png)

### Augment Query

When you chat with the document, the query is augmented with the context based on the similarity of the query to the document embeddings. The augmented query is then passed to the chat completion model.

### Chat completion

For local models, we use [llama.cpp](https://github.com/ggerganov/llama.cpp) for chat completion. If you choose a local model for chat completion, the app works completely offline.

For OpenAI compatible models, we use [OpenAI SDK](https://www.npmjs.com/package/openai) for chat completion. This allows us to support online providers like [Groq](https://twitter.com/recursechat/status/1782194309699449014) and [Together AI](https://twitter.com/recursechat/status/1781039660900512097), as well as endpoints that support OpenAI compatible API such as [Ollama](https://recurse.chat/ollama/).
If you use an online LLM provider, you don't need to worry about incurring a large embedding cost as you only pay for the chat completion API.

## What's next?

Many of our users have quite a few documents that they want as a persistent context of their conversations. We are working on making chatting with your wealth of local documents easier.

We'd also love to hear about your ideal local document workflows and use cases, and how we can make RecurseChat more useful for you. Feel free to reach out to us on [Twitter](https://twitter.com/recursechat)
or [Email](mailto:feedback@recurse.chat).

[^1]: You can start a llama.cpp server with `-m` param pointing to your embedding GGUF model and `--embedding` to enable embedding.
[^2]: Qdrant Benchmark: https://qdrant.tech/benchmarks/
[^3]: According to [this comment](https://github.com/orgs/qdrant/discussions/2914#discussioncomment-7455058), Qdrant scales to billions of vectors.


Local Docs, Local AI: Chat with PDF locally using Llama 3

Multimodal LLM has brought LLM to new dimensions. When LLMs can see, their capabilities multiply. GPT-4V(ision) produced some impressive demos, including understanding jokes in images, acting as e-sports commentator, turning mock ups into apps and reproducing pictures in novel styles.




What if you can have a GPT-4V like model running on your laptop? [LLaVA](https://llava-vl.github.io/) is an Open Source multimodal model similar to GPT-4V, reaching 85.1% of relative score in visual chat compared with GPT-4V. Here's how to get LLaVA up and running on macOS.



<figure align="center">
    <img src="/media/llava-webui-example.png"  />
    <figcaption>LLaVA WebUI </figcaption>
</figure>

## Installation

Prerequisites: Install [miniconda](https://docs.conda.io/projects/miniconda/en/latest/).

```shell
mkdir -p ~/miniconda3
curl https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm -rf ~/miniconda3/miniconda.sh
```

Follow [LLaVA installation instructions](https://github.com/haotian-liu/LLaVA/blob/main/docs/macOS.md):

Clone the repository:

```shell
git clone https://github.com/haotian-liu/LLaVA.git
cd LLaVA
```

Install Python dependencies:

```shell
conda create -n llava python=3.10 -y
conda activate llava
python -mpip install --upgrade pip  # enable PEP 660 support
pip install -e .
pip install torch==2.1.0 torchvision==0.16.0
pip uninstall bitsandbytes
```

## Usage

You can either use Web UI or CLI for inference. You'd need to add `--device mps` for running model worker or CLI on Apple silicon.

**Web UI:**

First start controller, gradio web server, and start a model worker, then go to http://localhost:7860/. You can either specify `liuhaotian/llava-v1.5-13b` as `--model-path` (models are downloaded to `~/.cache/huggingface/hub/`), or download models from https://huggingface.co/liuhaotian/llava-v1.5-13b and specify the local model path.

Sometimes I got the error `"NETWORK ERROR DUE TO HIGH TRAFFIC. PLEASE REGENERATE OR REFRESH THIS PAGE."` on the Web UI, and model worker crashes. Restarting model worker would resolve this issue.

```shell
# activate conda where you start controller, web server or model worker
conda activate llava

# gradio controller and web server
python -m llava.serve.controller --host 0.0.0.0 --port 10000
python -m llava.serve.gradio_web_server --controller http://localhost:10000 --model-list-mode reload

# launch model worker
python -m llava.serve.model_worker --host 0.0.0.0 --controller http://localhost:10000 --port 40000 --worker http://localhost:40000 --device mps --model-path liuhaotian/llava-v1.5-13b
```

**CLI**:

Substitute `--image-file` with your image URL or path to local file.

```shell
conda activate llava
python -m llava.serve.cli \
    --model-path liuhaotian/llava-v1.5-7b \
    --image-file "https://llava-vl.github.io/static/images/view.jpg" \
    --device mps
```

## Ending notes

An even easier way if you just want to spin up the Web UI is to use [llamafile](https://github.com/mozilla-Ocho/llamafile), the latest hotness which compresses LLMs into a single executable with local web server or CLI. Follow [Simon Willison's guide](https://simonwillison.net/2023/Nov/29/llamafile/) here and it's a matter of downloading and executing a single file executable to run LLMs locally.

 Running LLaVA, an Open Source GPT-4V alternative on a Mac with Apple Silicon

## Introduction

Introducing "CaveTalkFun", the world's first programming language designed for cavemen. It uses natural language conversations between characters to represent functions.

![](/media/cavetalkfun/intro.png)

## Painter

Here's how you do "Hello world" in CaveTalkFun:

![](/media/cavetalkfun/cavepainter.png)

## Repeater

Need to do something over and over? Tell the repeater.

![](/media/cavetalkfun/repeater.png)

## Mapping a skill over a list of rocks

You can compose cavemen! Just hand the skiller to a magician:

![](/media/cavetalkfun/mapper.png)

## Future features

More exciting features coming to CaveTalkFun including Multi-modal Input, Contextual Assistance, Intuitive Visualization, Prehistoric-themed Libraries, and Interactive Learning!

![](/media/cavetalkfun/future.png)

CaveTalkFun - Prehistoric functional programming

> Can you write docs for the **public** APIs?

I vividly recall this feedback on my 2k-line PR with a deadline for reviewing. Over the years, it's a piece of advice that sticks as a surprisingly simple, but amazingly effective way to improve codebase quality.

Documenting public APIs compels you to reify and clarify your abstractions. The emphasis on **public** is important, as you are articulating your abstractions in a human-interpretable way. They are co-locating with your code, saving the trips to doc sites.

Considering the cost of writing and maintaining docs up to date might give you pause. But the time invested in writing would turn out to be trivial, compared to the time saved for fellow engineers on your team, or even yourself, staring blankly at the code and brain interpreting it, 20-level deep in a debugger stack, or frantically slack DMing. The values compound over time. Code is not a write-only medium. It's written for humans to read (and language models too). The more you write, the better you become at writing it.


<figure align="center">
    <img src="/media/human-reading-code.png"  />
    <figcaption>Human reading code by Stable Diffusion</figcaption>
</figure>

What about maintenance? Don't you need to maintain the stale docs if they get out of date? Well, if you find the docs get stale frequently, it's usually a sign that you have the wrong abstractions. Think about refactoring the abstractions instead. It's easy to delete the doc if they can't keep themselves up to date. Being [easy to delete](https://programmingisterrible.com/post/139222674273/write-code-that-is-easy-to-delete-not-easy-to) is another sign that docs are good code. Docs are [meta languages](https://frantic.im/meta-language/), but they are the types of meta languages that exist as code. They can be easily incorporated into code should you find the necessity.

In practice, docs could sometimes look like a verbatim of function signatures, which appears to contradict the conventional wisdom of ["Comments should not duplicate the code"](https://stackoverflow.blog/2021/12/23/best-practices-for-writing-code-comments/#:~:text=Rule%201%3A%20Comments%20should%20not%20duplicate%20the%20code,-Many%20junior%20programmers&text=While%20this%20may%20be%20a,time%20to%20write%20and%20read). I've explained above how this wisdom doesn't apply to writing docs for public APIs, in terms of writing and maintaining the docs. The argument against visual clutter doesn't hold up since you can fold docs easily in modern IDEs. On the contrary, they give you additional context when you use the interfaces.

A simple way to improve codebase quality

I recently was fascinated by Raspberry Pi and the maker communities behind it. One of the useful projects you can build with Raspberry Pi is [Pi-hole](https://pi-hole.net/). It blocks ads, tracking and malicious websites on every device on your local Wi-fi network, and have an easily manageable web interface.

_Caveat: Pi-hole could not block Youtube Ads. Your best bet would be using a browser like [Brave](https://brave.com/) (Founded by Brendan Eich, creator of JavaScript) or paying for Youtube premium._

## What you will need

- A [Raspberry Pi](https://www.raspberrypi.com/), for example Raspberry Pi 4 Model B
- Wi-Fi Router

## Connect Raspberry Pi to your local network

First, you would need to connect Raspberry Pi to your local network using ethernet cable or Wi-fi network. Additionally, you might want to enable SSH access on your Pi.

To connect to network:

- If you have a monitor, [connect to the monitor using an HDMI cable](https://www.raspberrypi.com/documentation/computers/getting-started.html#connecting-a-display), and [connect to your network from the Desktop GUI](https://www.raspberrypi.com/documentation/computers/configuration.html#using-the-desktop).
- Alternatively, you can use Raspberry Pi without a monitor (headless mode), and [connect from command line](https://www.raspberrypi.com/documentation/computers/configuration.html#wireless-networking-command-line).

For remote access, head to [Remote access](https://www.raspberrypi.com/documentation/computers/remote-access.html) and [SSH configuration](https://www.raspberrypi.com/documentation/computers/remote-access.html#ssh) documentation for setup instructions.

- In GUI, Go to Preferences → Raspberry Pi Configuration → Interfaces → Enable SSH, then `ssh pi@<pi-IP>`.
- In headless mode, create an `ssh` file and `userconf.txt` (See [Configuring a User](https://www.raspberrypi.com/documentation/computers/configuration.html#configuring-a-user)) on the boot partition of the SD card.

## Installation

You can follow the steps on the [official website](https://pi-hole.net/) to install Pi-hole on a Raspberry Pi 4 Model B.

On your Pi, clone the [Pi-hole repository](https://github.com/pi-hole/pi-hole) and run the installation script:

```bash
git clone --depth 1 https://github.com/pi-hole/pi-hole.git Pi-hole
cd "Pi-hole/automated install/"
sudo bash basic-install.sh
```

Follow through the installation wizard. [This article](https://privacyinternational.org/guide-step/4341/raspberry-pi-setup-and-run-pi-hole) has some good information about the wizard steps.

## Router DNS Configuration

Next, you need to configuring the router's DHCP clients to use Raspberry Pi as their DNS Server so that when the clients resolves IP address of an Ad server Pi-hole would block it. To do that you need a couple of things:

- Raspberry Pi's IP Address
- Access to router's web admin interface. You can find your router IP using `netstat -rn | grep default`. This returns the IP of the default gateway, for example `192.168.0.1`.

### Find Raspberry Pi's IP Address

There are [plenty of ways](https://www.raspberrypi.com/documentation/computers/remote-access.html#ip-address) to find your Raspberry Pi's IP address.

Since my Raspberry Pi supports mDNS by the [Avahi service](https://wiki.archlinux.org/title/avahi), `ping raspberrypi.local` and `ping6 raspberrypi.local` from my computer return Pi's IP addresses.

If that's not the case for you, you could try out the `nmap` method. Run `sudo nmap -sn <your-computer-IP>/24` to scan the devices on your local network and look for the hostname containing Raspberry Pi.

### Static IP Address

You'll want the Raspberry Pi's IP address to be static so that you won't need to reconfigure Pi-hole and your router if you restart Raspberry Pi.

To set static IP address on a Raspberry Pi, edit `/etc/dhcpcd.conf` and add the following. You can learn more about [dhcpcd here](https://wiki.archlinux.org/title/dhcpcd#Static_profile).

```bash
interface wlan0 # interface eth0 if you are using ethernet cable
static ip_address=<your-pi-IP>/24
static routers=<router-ip>
static domain_name_servers=
```

To apply the changes reboot using `sudo reboot` or bring down / bring up the network interface:

```bash
sudo ip link set wlan0 down
sudo ip link set wlan0 up
```




Also, reserve a static IP for the Raspberry Pi's MAC address in router admin page DHCP settings.

**Reconfigure Pi-hole**

If the IP Address of the Pi changes, you will need to reconfigure Pi-hole. Opening a terminal from Raspberry Pi and running `pihole -r` does the job.

### Configure Router DNS

Configuring DNS is pretty straightforward: Check the manual of your router brand, go to the router admin page and set DNS override to the IP address of the Raspberry Pi.

Note that it's [recommended](https://discourse.pi-hole.net/t/why-should-pi-hole-be-my-only-dns-server/3376) to use Pi-hole as the **single** DNS server (Or servers, if you care about redundancy) because your clients might send blocked requests to secondary DNS Servers.



## Pi-hole Admin

Go to `http://pi.hole/admin` or `http://<Your-Pi-IP>/admin` to manage Pi-hole.

To check Pi-hole service status, run `pihole status` on the command line on the Raspberry Pi.

You can also use dig to find out the performance of DNS queries. For example: `dig www.youtube.com | grep "Query time"` .