DEV Community: Gan Mahmud

How To Install Caveman In Codex On macOS And Windows

Gan Mahmud — Fri, 17 Apr 2026 06:32:28 +0000

If you use Codex inside VS Code and want shorter, more compressed responses, caveman is a simple local plugin that adds that behavior.

This guide shows the full setup for both macOS and Windows. It uses a local plugin plus a local marketplace entry, so you do not need to publish anything remotely.

What Caveman Does

caveman adds a skill that tells Codex to answer in a much tighter style:

fewer filler words
shorter phrasing
preserved technical meaning
optional stronger compression levels

It can also auto-activate on session start if you add the optional .codex hook files.

Files You Need

The plugin is made of three parts:

a plugin folder: plugins/caveman
a marketplace file: .agents/plugins/marketplace.json
optional Codex hook files: .codex/hooks.json and .codex/config.toml

Folder Layout

Your workspace should end up looking like this:

your-project/
├─ .agents/
│  └─ plugins/
│     └─ marketplace.json
├─ .codex/
│  ├─ config.toml
│  └─ hooks.json
└─ plugins/
   └─ caveman/
      ├─ .codex-plugin/
      │  └─ plugin.json
      ├─ assets/
      │  ├─ caveman-small.svg
      │  └─ caveman.svg
      └─ skills/
         └─ caveman/
            └─ SKILL.md

Option 1: Install In One Project Only

Use this if you want caveman available only in one repo or one VS Code workspace.

macOS

If your project lives at:

/Users/your-name/code/my-app

create these folders inside that project:

/Users/your-name/code/my-app/plugins/caveman
/Users/your-name/code/my-app/.agents/plugins
/Users/your-name/code/my-app/.codex

Windows

If your project lives at:

C:\Users\your-name\code\my-app

create these folders inside that project:

C:\Users\your-name\code\my-app\plugins\caveman
C:\Users\your-name\code\my-app\.agents\plugins
C:\Users\your-name\code\my-app\.codex

Option 2: Install As A Home-Local Plugin

Use this if you want caveman available across multiple projects.

macOS

~/plugins/caveman
~/.agents/plugins/marketplace.json

If you also want Codex hooks globally, use:

~/.codex/hooks.json
~/.codex/config.toml

Windows

C:\Users\your-name\plugins\caveman
C:\Users\your-name\.agents\plugins\marketplace.json

If you also want Codex hooks globally, use:

C:\Users\your-name\.codex\hooks.json
C:\Users\your-name\.codex\config.toml

Step 1: Add The Plugin Manifest

Create:

plugins/caveman/.codex-plugin/plugin.json

Use this content:

{
  "name": "caveman",
  "version": "0.1.0",
  "description": "Ultra-compressed communication mode. Cut filler. Keep technical accuracy.",
  "author": {
    "name": "Julius Brussee",
    "url": "https://github.com/JuliusBrussee"
  },
  "homepage": "https://github.com/JuliusBrussee/caveman",
  "repository": "https://github.com/JuliusBrussee/caveman",
  "license": "MIT",
  "keywords": [
    "productivity",
    "communication",
    "brevity",
    "writing"
  ],
  "skills": "./skills/",
  "interface": {
    "displayName": "Caveman",
    "shortDescription": "Talk like caveman. Cut filler. Keep technical accuracy.",
    "longDescription": "Ultra-compressed communication mode for Codex. Use fewer words. Keep exact technical substance.",
    "developerName": "Julius Brussee",
    "category": "Productivity",
    "capabilities": [
      "Write"
    ],
    "websiteURL": "https://github.com/JuliusBrussee/caveman",
    "privacyPolicyURL": "https://github.com/JuliusBrussee/caveman/blob/main/README.md",
    "termsOfServiceURL": "https://github.com/JuliusBrussee/caveman/blob/main/LICENSE",
    "defaultPrompt": [
      "Use caveman mode. Cut filler. Keep technical accuracy."
    ],
    "brandColor": "#6B7280",
    "composerIcon": "./assets/caveman-small.svg",
    "logo": "./assets/caveman.svg",
    "screenshots": []
  }
}

Step 2: Add The Skill File

Create:

plugins/caveman/skills/caveman/SKILL.md

Use this content:

---
name: caveman
description: ">"
  Ultra-compressed communication mode. Cuts token usage by speaking like caveman
  while keeping technical accuracy. Supports lite, full, ultra, wenyan-lite,
  wenyan-full, and wenyan-ultra. Use when the user asks for caveman mode,
  fewer tokens, terse output, or invokes `$caveman`.
---

Respond terse like smart caveman. Technical substance stay. Fluff die.

## Persistence

Active every response until user says `stop caveman` or `normal mode`.
Default level: `full`.
Switch with `$caveman lite|full|ultra|wenyan-lite|wenyan|wenyan-ultra`.

## Rules

- Drop articles, filler, pleasantries, and hedging.
- Fragments OK.
- Prefer short synonyms.
- Keep technical terms and quoted errors exact.
- Leave code blocks unchanged.
- Use pattern: `[thing] [action] [reason]. [next step].`

## Levels

- `lite`: tight full sentences, no filler.
- `full`: no articles, fragments OK.
- `ultra`: abbreviate hard, use arrows for causality.
- `wenyan-lite`: semi-classical compression.
- `wenyan`: full classical Chinese terseness.
- `wenyan-ultra`: maximum compression with classical tone.

## Auto-Clarity

Use normal language for destructive actions, security warnings, or any case where
extra clarity reduces risk. Resume caveman after the clear part is done.

## Boundaries

Code, commits, and PR text stay normal unless the user asks otherwise.

Step 3: Add The Marketplace Entry

Create:

.agents/plugins/marketplace.json

If the file does not exist yet, use:

{
  "name": "Local Plugins",
  "interface": {
    "displayName": "Local Plugins"
  },
  "plugins": [
    {
      "name": "caveman",
      "source": {
        "source": "local",
        "path": "./plugins/caveman"
      },
      "policy": {
        "installation": "AVAILABLE",
        "authentication": "ON_INSTALL"
      },
      "category": "Productivity"
    }
  ]
}

If you already have a marketplace file, just append the caveman entry inside the plugins array.

Step 4: Add The Optional Auto-Start Hook

If you want Caveman mode to load automatically when Codex starts or resumes, create:

.codex/hooks.json
.codex/config.toml

Use:

`.codex/hooks.json`

{
  "hooks": {
    "SessionStart": [
      {
        "matcher": "startup|resume",
        "hooks": [
          {
            "type": "command",
            "command": "echo 'CAVEMAN MODE ACTIVE. Rules: Drop articles, filler, pleasantries, hedging. Fragments OK. Short synonyms. Pattern: [thing] [action] [reason]. [next step]. Code, commits, security warnings: write normal. User says stop caveman or normal mode to deactivate.'",
            "timeout": 5,
            "statusMessage": "Loading caveman mode"
          }
        ]
      }
    ]
  }
}

`.codex/config.toml`

[features]
codex_hooks = true

Step 5: Add The Asset Files

The manifest references two SVG files:

plugins/caveman/assets/caveman.svg
plugins/caveman/assets/caveman-small.svg

You can copy them from the upstream repo or create your own icons with the same file names.

If you skip them, the plugin may still work, but the UI icons can be missing or broken.

Step 6: Restart VS Code And Reopen Codex

After the files are in place:

close any open Codex session in VS Code
reload the VS Code window
reopen Codex
open the plugin list or marketplace view
install Caveman

If you used the optional .codex hook files, you should also see the startup message when a session starts or resumes.

Step 7: Test It

Try prompts like:

Use caveman mode
$caveman full
$caveman ultra
stop caveman

If the plugin is installed correctly, Codex responses should become much more compressed.

Common Problems

The Plugin Does Not Show Up

Check these first:

marketplace.json is valid JSON
the plugin path is exactly ./plugins/caveman
plugin.json is inside plugins/caveman/.codex-plugin/
you reloaded VS Code after adding the files

The Skill Does Not Trigger

Check:

skills in plugin.json is set to ./skills/
the skill file path is exactly plugins/caveman/skills/caveman/SKILL.md
the frontmatter at the top of SKILL.md is valid

Hooks Do Not Run

Check:

.codex/config.toml contains codex_hooks = true
.codex/hooks.json is valid JSON
you restarted or resumed the Codex session

Final Notes

For a single repo, the repo-local setup is simplest.

For multiple repos, the home-local setup is cleaner because you install the plugin once and reuse it everywhere.

Upstream project:

Caveman on GitHub

Priority Queue: Creating order from chaos

Gan Mahmud — Thu, 26 Oct 2023 06:46:47 +0000

In the world of computer science, think of a priority queue as a special kind of waiting line. It's like the lines you find at the grocery store or a fast-food restaurant, but with a twist. In a priority queue, everyone comes with a tag – their "priority."

The catch is that the important folks get to cut ahead of others. If you're a VIP, you go first, no questions asked. But what if two people have the same VIP status? Well, here's where it gets interesting. Depending on the rules, it could be a first-come, first-served situation, or it might be a bit like a free-for-all - you never really know who goes next in that case.

Before delving into how priority queues are implemented, let's take a moment to explore where and why they are used. These dynamic data structures play a pivotal role in various fields, helping to streamline and prioritize tasks in real-world scenarios. Here are some key applications:

Task Scheduling: Operating systems often use priority queues to manage and schedule tasks. The tasks with higher priority are executed first, ensuring efficient resource allocation.
Event-Driven Simulations: In simulations like network traffic or game engines, priority queues help schedule events based on their time of occurrence.
Data Compression: Priority queues are the key to Huffman coding, a widely used data compression technique.

Priority queues can be implemented in several ways, but one of the most common methods uses a data structure called a heap. A heap is a complete binary tree in which elements are organized so that the highest priority element is at the root.

Let's consider a simple example to illustrate this concept. Imagine we have a task management system, and we want to use a priority queue to schedule tasks. Each task is represented as an object with two attributes: a task description and a priority value. Here's how we can use a max heap to maintain the priority queue:

class MaxHeap:
    def __init__(self):
        # Initialize an empty heap.
        self.heap = []

    def push(self, task):
        # Add a task to the heap and reorganize the heap.
        self.heap.append(task)
        self._heapify_up()

    def pop(self):
        if not self.is_empty():
            # Swap the highest-priority task (at the root) with the last task.
            self._swap(0, len(self.heap) - 1)
            # Remove the highest-priority task and reorganize the heap.
            highest_priority_task = self.heap.pop()
            self._heapify_down()
            # Return the highest-priority task.
            return highest_priority_task

    def _heapify_up(self):
        index = len(self.heap) - 1
        while index > 0:
            parent_index = (index - 1) // 2
            if self.heap[index]["priority"] > self.heap[parent_index]["priority"]:
                # Swap the task with its parent if it has higher priority.
                self._swap(index, parent_index)
                index = parent_index
            else:
                break

    def _heapify_down(self):
        index = 0
        while True:
            left_child_index = 2 * index + 1 # because index starts at 0 and the first child is at index 1
            right_child_index = 2 * index + 2
            largest = index
            if (
                left_child_index < len(self.heap)
                and self.heap[left_child_index]["priority"]
                > self.heap[largest]["priority"]
            ):
                # Compare with the left child and update 'largest' if necessary.
                largest = left_child_index
            if (
                right_child_index < len(self.heap)
                and self.heap[right_child_index]["priority"]
                > self.heap[largest]["priority"]
            ):
                # Compare with the right child and update 'largest' if necessary.
                largest = right_child_index
            if largest == index:
                # If 'largest' is still the current index, we're done.
                break
            # Swap the task with the child that has higher priority.
            self._swap(index, largest)
            index = largest

    def is_empty(self):
        # Check if the heap is empty.
        return len(self.heap) == 0

    def _swap(self, i, j):
        # Swap two tasks in the heap.
        self.heap[i], self.heap[j] = self.heap[j], self.heap[i]

# Example usage
pq = MaxHeap()
pq.push({"description": "Task A", "priority": 3})
pq.push({"description": "Task B", "priority": 1})
pq.push({"description": "Task C", "priority": 2})

print(pq.pop())  # Output: {'description': 'Task A', 'priority': 3}
print(pq.pop())  # Output: {'description': 'Task C', 'priority': 2}
print(pq.pop())  # Output: {'description': 'Task B', 'priority': 1}

It's worth emphasizing that, even though I've just shown how to implement a priority queue using a heap, they're not interchangeable. It's a bit like the difference between having a shopping list on your phone or a piece of paper – the list is the same, but the way you handle it is different. In the end, a priority queue is like your secret weapon in organizing tasks, creating order from chaos.

Deploy python fastapi project from github to vercel (without vercel cli)

Gan Mahmud — Mon, 09 Oct 2023 07:03:37 +0000

I used to deploy my pet projects to Heroku using their free tier until it had a free tier. Let's all acknowledge that we have a fondness for free tiers, especially when we want to test our projects on a server.

I once built a text-to-ASCII art app using FastAPI. To demonstrate it, I initially utilized Heroku. However, due to the discontinuation of its free tier, I haven't been able to keep my project updated with live demos."

Now, let's talk about Vercel. I assume most of you are already familiar with it, so I won't delve into the specifics. Following some research and experimentation, I discovered that deploying a Python project on Vercel is a straightforward process. All you require is a 'vercel.json' file.

Here's what I did to deploy my FastAPI app to Vercel -

1) Add a vercel.json file in the project root

{
    "version": 2,
    "builds": [
        {
            "src": "main.py",
            "use": "@vercel/python"
        }
    ],
    "routes": [
        {
            "src": "/(.*)",
            "dest": "main.py"
        }
    ]
  }

In the builds.src use your app entrypoint, mine is app.py in the app root. Same goes for routes.src

Login to Vercel and add new project
Go to Continue with Github as shown below -

Connect Your GitHub Account
Authorize Vercel to access your GitHub repositories if prompted.
Select the GitHub repository you want to import

That's it. The project will be deployed and it build and re-deploy each time you push a commit to your main branch.

GitHub: https://github.com/ganmahmud/fastapi-text-asciify
Live demo on Vercel: https://fastapi-text-asciify-npt1siwyq-ganmahmud.vercel.app

How ChatGPT could possibly disrupt google search services and change SEO forever

Gan Mahmud — Fri, 09 Dec 2022 06:04:34 +0000

It's no secret that Google has been the dominant player in the search game for decades. But with the rise of ChatGPT, a large language model trained using the same technique as GPT-3 with a focus on conversational language, the search giant may finally have some serious competition.

What sets ChatGPT apart from traditional search engines like Google is its ability to understand and respond to a wide range of natural language queries. This makes it particularly effective at providing accurate and relevant answers to complex questions, just like Google does.

But ChatGPT has another trick up its sleeve: it's highly adaptable and can learn to respond to different conversational styles and contexts, providing personalized responses to each user. This makes it a more engaging and effective tool than traditional chatbots.

In addition, ChatGPT is highly scalable and can be easily integrated into a variety of applications and platforms, making it a powerful tool for developers and businesses looking to build advanced conversational AI systems.

One potential way ChatGPT could be used as an alternative to Google Search is by integrating it into a conversational AI system that can understand natural language queries and provide relevant and accurate answers. This would allow users to simply ask questions in natural language and receive relevant responses, making the search process more intuitive and user-friendly.

This would also have a major impact on the way businesses approach search engine optimization (SEO). Instead of focusing on keyword optimization, businesses would need to prioritize the creation of high-quality, informative content tailored to the needs and interests of their target audience in order to rank highly on ChatGPT's search results pages.

It's still unclear how quickly ChatGPT will be adopted, but it's clear that it has the potential to disrupt the search industry and change the way businesses approach SEO. With its advanced language processing abilities and adaptability to different conversational styles, ChatGPT could be a game-changer in the world of search.

Take your Windows PowerShell to the next level by Starship

Gan Mahmud — Tue, 02 Nov 2021 16:11:55 +0000

Old habits die hard. I still use Windows as the primary OS for my development workflow. Whenever I was interested to any tool exclusive to Linux or Mac OS, I tried to find a windows alternative.

In this case, the tool of interest was Zsh terminal. The default appearance of PowerShell is quite boring and I wanted to give my shell terminal a little visual flair. I was really impressed with Zsh terminal and what it could look like with the help of Oh my Zsh. So I took that as an inspiration and began my quest for a decent Windows/Cross platform alternative.

Along came Starship - a Rust powered, highly customizable and easy to use cross-shell platform.

Here's a before-after comparison of Starship installed PowerShell

Before:

After:

Here's how I did it -

1) Installing a nerd font

We have to install and enable a nerd font in the terminal. You can choose any font from the list. I used "MesloLGS NF".

2) Installing starship using scoop



scoop install starship

If you do not have scoop installed, run the following command in your PowerShell to install it -



iwr -useb get.scoop.sh | iex

Note: if you get an error you might need to change the execution policy with Set-ExecutionPolicy RemoteSigned -scope CurrentUser

3) Running starship on PowerShell startup

We will have to initiate starship each time a PowerShell instance starts. We can achieve this by adding the following to the end of Microsoft.PowerShell_profile.ps1:



Invoke-Expression (&starship init powershell)

You can check the location of this file by querying the $PROFILE variable in PowerShell. Typically the path is ~\Documents\PowerShell\Microsoft.PowerShell_profile.ps1

4) Refreshing the PowerShell session

Enter the following command to refresh the current PowerShell session



. $profile

Voila!!! You can see its working. Now, on to the fun part which is configuring.

5) Configuration

First from the PowerShell you can type the following command to create the .config directory and a starship.toml file for the configuration.



New-Item -ItemType Directory -Force ~/.config;New-Item -ItemType file ~/.config/starship.toml;

or if you like to use git bash, you may use the following command -



mkdir -p ~/.config && touch ~/.config/starship.toml

you will find the newly created directory and config file at the user's home directory, e.g. C:\Users<UserName>

Open the file with your preferred editor and start playing with the configuration.

Pro Tip: you can just run these commands if you want to open the starship.toml file with Visual Studio Code :



cd  ~/.config;code starship.toml

Here's my preset -
 - This will show the correct icon when a nerd font will be enabled



command_timeout = 500
format = "$directory$git_branch$time$cmd_duration$character"
[line_break]
disabled = true

[character]
success_symbol = "[➜](bold green) "
error_symbol = "[✗](bold red) "

[cmd_duration]
min_time = 500
format = "took [$duration](bold yellow) "

[directory]
read_only = " "
truncation_length = 3
truncation_symbol = "~/"

[git_branch]
symbol = "  "
style = "bold #e8ec00 inverted"
format = "on [$symbol$branch ]($style) "

[time]
disabled = false
format = '[ 🕙 $time ]($style) '
time_format = "%I:%M:%S %p"
utc_time_offset = "+6"
style = "bold bg:#8a15e2"

[git_commit]
disabled = true

[git_state]
disabled = true

[git_status]
disabled = true

[package]
disabled = true

That's pretty much it. If you face any issue with installation, feel free to drop a comment. I would be happy to help 🙂

A "Brave" way to brows blocked content from terminal

Gan Mahmud — Wed, 13 Oct 2021 09:03:27 +0000

tl;dr

Add the brave executable to environment variables
From the terminal type: brave --tor <URL>

Apart from Google Chrome, Brave has been one of my go-to browser, specially for its "New Private Window with Tor" feature. Basically it acts as a VPN for browsing ISP/country blocked contents.

I never liked installing any chrome extension or use any free VPN solution (let alone buying it) to brows any blocked content. In stead, I used to fire up the Brave browser and open a tor tab to load the desired URL. But it was still too much work to load a simple URL, well at least for a software professional.

Along came the idea to do it from terminal.

After some research I found out that Brave has a CLI option to open any URL with "New Private Window with Tor". I only have to use the following command -

path-to-brave-executable --tor <URL>

For my convenience, I added the brave executable to my environment variables. Now I can type brave --tor https://medium.com/ in my terminal and voilà.