DeepakNess - Everything

CogSend now deploys in one click

2026-10-10T15:36:58Z

CogSend now has a Deploy to Cloudflare button, so you can deploy it to your own Cloudflare account without a terminal. Here's the step-by-step process to deploy and update.

Go to cogsend.com.
Click the Deploy to Cloudflare button and sign in to Cloudflare.
Select your GitHub account, and tick "Create private Git repository".
Get an APP_ENCRYPTION_KEY from cogsend.com/key or by running openssl rand -hex 32 command in your terminal, fill it in, and save a copy.
Click "Create and deploy", and wait for the build to complete. It usually takes less than a minute.
Open the workers.dev URL it assigns, enter the same key with an email and password to create your account, then scan the QR with an authenticator app for TOTP setup.
And done! Connect your accounts, and start scheduling.

I also asked Claude to create a video showing the same, and I think it did a great job.

Updates go through the GitHub repository the button created, with no Cloudflare token.

The first time, go to Settings → Instance → "Add the Update action to the repository" and commit the file GitHub opens.
When a new release is out, click "Update on GitHub" → Run workflow, and it deploys in a couple of minutes.
Or add the repo variable AUTO_UPDATE=true, and patch releases install themselves daily.

And every release is signed, and the update action refuses any file the signature doesn't cover. More details are in the updating docs.

Animating webpages with Claude is fun

2026-10-04T10:33:43Z

For a project, I decided to add a cute animation on the /admin login page where a mascot looks away and closes its eyes when typing the username or password, and with just one prompt Claude did a great job. I asked it to create multiple different versions that I can choose from, and here's a video showing the same.

It was a very simple prompt, and I'm sure that Claude could have done much better with a more defined prompt.

It's crazy.

I wish I set up a local LLM before a long journey

2026-10-01T10:39:49Z

I'm on a long ~20-hour train journey right now (you know I love train journeys), and now thinking that I should have downloaded and set up any small LLM which runs smoothly on my 16GB MacBook M2 Air. Like I wouldn't do hardcore coding with it, but I still could do a lot of things with it, as even a 1B parameter would be much smarter than me in many fields today.

I tried downloading Gemma 7B and a few others, but the network is not stable and it's failing each time. My best chance is downloading when the train stops for 15-20 mins on a major station for re-stocking supplies.

Fingers crossed. 🤞

CogSend has its first sponsor

2026-09-27T04:04:45Z

CogSend also as a sponsor now!

Zernio has just started sponsoring CogSend and that brings a convenient way to connect socials to CogSend without creating developer apps of your own. It's optional, and connecting directly with your own apps still works.

By the way, it's a monthly pledge, and it will help me keep working on CogSend to make it better. And you can learn more about this from our docs.

Excited for this.

Nearing 2 Billion tokens usage in a day

2026-09-25T02:09:18Z

I think DeepSeek V4.1 Flash is the best model that's ever released, especially when price is considered. I have been using hundreds of millions of DeepSeek tokens every single day, and was about to touch the 2B mark yesterday.

I'm mostly using via OpenCode Go API inside the Pi agent these days and their new dashboard is pretty awesome to show the total usage even when you use via their API. And as you see in the screenshot by yourself. I am working on CogSend, SharePDF, and a few other projects and was running 5-6 agents continuously that amounted to this many tokens.

In fact, I am surprised myself about my token usage. In the last few months, so much has changed in how and how much I use AI for coding, and I'm only optimistic about the future.

Building CogSend: A Self-Hosted Social Media Scheduler

2026-09-23T09:09:51Z

I have been using Typefully for a long time and it is genuinely great, but it supports a fixed set of platforms and I wanted to decide that for myself. So I built my own. Say hello to CogSend, a self-hosted social media scheduler.

CogSend is open source under the MIT license and it runs on your own free Cloudflare account. There is no monthly fee and no account with me, and your platform credentials stay in your infrastructure. It currently supports Mastodon, Bluesky, LinkedIn, Threads and X with more platform support coming soon.

What it can do

The main idea is, you write a post once, then customize it per platform if you want. There is a Global tab plus a tab for each platform you override, so the X version can stay short while the LinkedIn version says the same thing at length. If you paste a long draft, it splits into a thread that fits the tightest platform you selected, counted the way that platform counts.

Publish now or schedule: Every destination reports its own result, so one platform failing does not take the rest down with it.
Retries take care of themselves: Retryable failures back off and try again a few times. If a platform keeps refusing (sometimes, happens with Threads), the post parks under Failed with the reason, and you can fix it and retry.
Manage it all from Posts: Cancel or reschedule a queued post without opening it, or retry only the destinations that failed.
Images and links: Supports up to four images per post with alt text for each one and preview cards for links.
Insights: Published against failed over 7, 30 or 90 days, bucketed in your own timezone, with failures grouped by reason instead of a wall of API errors.
Locked down: One admin account with an authenticator app, credentials encrypted at rest, and an API key for scripts, Shortcuts and cron jobs.

How to install

You need Node and a Cloudflare account with Workers access, D1 and R2 available. And the whole install process is just two commands:

git clone --depth 1 https://github.com/cogsend/cogsend.git cogsend
cd cogsend && npm install && npm run setup

The setup does everything – creates the database and the bucket, generates the secrets, applies the migrations, deploys the Worker, and then signs in once against the live site to prove it works. At the end just open the final URL it prints, scan the QR with an authenticator app, save the backup codes, and start connecting your social accounts.

The Cloudflare free plan is enough for a personal instance. By the way, R2 does ask for a payment method on file even on the free tier, but the first 10 GB each month are free.

I think, it's more than enough for a single user, no?

Why I built it

Every new post and note I published went out through a small script to the same two platforms. It worked, but I wanted per-post control over where things go, and room to add the platforms I actually use. That is the part CogSend fixes, and now the accounts and the scheduling are mine to change.

I already self-host a few other things, like this website running from a Raspberry Pi, so putting the scheduler on infrastructure I control felt natural, and the best thing is I loved the process of building it.

What's next

First, I will be fixing the documentation and I want the setup to be clear enough that nobody has to read the repo to understand it. And I will record a few short videos for the parts that are easier to show than to write.

After that, will focus on adding more platforms – Instagram, TikTok and YouTube are the ones I am thinking about. Along with these, I'm thinking about more integration options as well.

These are early thoughts though, not the final roadmap.

The code is on GitHub and the site is cogsend.com. It is MIT licensed, so fork it and change whatever you want, and send PR as well.

That's it.

Raspberry Pi 4B with and without the fan

2026-09-15T03:08:11Z

I tried to keep my Raspberry Pi 4B device without the fan, and it reaches up to 50°C when it's hosting this experiment site pi.deepakness.com, as you see in the below screenshot.

But when I keep it in my room under the ceiling fan, the temperature is consistently below 40°C. By the way, earlier when it crashed, the temperature had reached over 75°C.

For now, I am keeping it without the fan but if temperature goes above 60 or so, I will place it under the fan.

Let's see.

Serving a Website from a 1 GB Pi 4B on Home WiFi

2026-09-13T22:00:16Z

I have a Raspberry Pi 4B at home on WiFi, and it serves a public website. It is a Rev 1.5 board with 4x Cortex-A72 at 1.8 GHz, 1 GB of RAM, a 64 GB microSD card and Debian 13 (trixie). Nothing is forwarded on my router, no ports are open, and my home IP address is never published.

The page is live at pi.deepakness.com, and it is about the machine serving it. You get live readings for CPU, memory, temperature, disk, network and WiFi signal, an hour of history, an availability record with the state of every service, the home connection measured four times a day, and how many people are reading right now.

The path from the internet to the Pi

The Pi sits on my home WiFi as a normal client.
Caddy serves the site files on 127.0.0.1:8080, which exists only inside the Pi.
A Cloudflare Tunnel dials out to Cloudflare and holds that connection open.
Cloudflare publishes the local address as a subdomain of mine, with TLS handled at the edge.

Caddy listens on localhost only, so nothing on my network can reach the site directly, and the tunnel is the only way in. There is no port forwarding on the router, no static IP, and no dynamic DNS record to keep updated.

I had the tunnel pattern written down earlier when I was looking at ways to publish local apps, and the feed reader that runs on this Pi uses the same route.

Getting in without opening SSH

Tailscale is the other half of this setup. The Pi is on my tailnet, which is a private network between my own devices, and it is how I open a shell on the Pi or reach anything else at home from anywhere. It runs as a system service and is not in the serving path at all. The website would work without it, and the admin access would work without the tunnel.

Port 22 is never exposed to the internet, and I still get a terminal on the Pi from basically anywhere.

What Caddy does

The config is mostly security headers and caching. These are the parts that matter, minus the headers:

:8080 {
	bind 127.0.0.1

	@page path / /index.html
	handle @page {
		header Cache-Control "public, max-age=0, s-maxage=60"
		file_server
	}

	@live path /hits.json /uptime.json /speedtest.json
	handle @live {
		header Cache-Control "public, max-age=0, s-maxage=15"
		file_server
	}

	handle /hit {
		respond 204
	}
}

The page is cached at the edge for 60 seconds and the data files for 15, which is just longer than the collector's sampling interval. The numbers stay seconds behind the Pi without the Pi answering every poll from every open tab, and the page's own polls still carry no-store, so those do come here.

/hit is one request per page load, answered with an empty 204 and never cached. That is how page views are counted. Counting them from the access log stopped working once the page was cached at the edge, since the Pi only saw cache fills and the counter advanced about once per edge location per minute, whatever the size of the audience.

That caching is what got it through the afternoon it was shared. Four IP addresses and later much more fetched the page in a loop, the combined peak reached 1,028 requests per second, and the first version of this setup crashed badly.

However, the same board then took 91 million requests in around 15 hours, with 85 million stopped at Cloudflare and 2.76 million served by origin, and it still stayed up.

What keeps it running

Caddy, the collector and the speed test run as systemd user services, symlinked into ~/.config/systemd/user/ from the project. And changes are committed in the repo on the Pi, then the affected unit restarts.

Each service has a memory cap, because memory is the thing that actually runs out on a 1 GB board:

MemoryMax=256M
MemoryHigh=192M
Environment=GOMEMLIMIT=192MiB

Here, Caddy and cloudflared are both Go, and Go holds on to its heap after a burst instead of giving it back. The GOMEMLIMIT above is the setting doing the real work, since the runtime then keeps itself under the soft cap instead of borrowing memory the Pi does not have.

A watchdog covers what I cannot. A two minute timer probes the public URL and reads the tunnel's memory, and restarts the tunnel if two probes fail or if it crosses 250 MB. It has restarted it a few times, mostly during the attack. A five second restart is cheaper than an outage nobody is watching.

The collector

Everything on the page comes from one Python file with no dependencies outside the standard library. It reads /proc and /sys every 10 seconds.

def meminfo():
    out = {}
    for line in rfile("/proc/meminfo").splitlines():
        key, _, rest = line.partition(":")
        out[key] = int(rest.split()[0])
    return out

The JSON goes into /dev/shm, which is RAM, because a file every 10 seconds is over 3 million writes a year and the SD card is the first part of a Pi to fail. The counters are the only thing that touches the card, flushed once a minute with a .bak beside them, and every write goes through os.replace so a reader never sees a half-written file.

The bug worth reading this post for: The collector used to empty the access log once it passed a size cap. Caddy holds that file open and keeps its own position in it, so the next write landed past the new end – a sparse file, enormous in size and nearly empty in content, over the cap again on the next tick, emptied again ten seconds later, forever. Visitors read 1 while the site was fast, the CPU was idle and every service reported active. But now, Caddy rotates the log itself, and the collector only reads it.

The counters: Page views come from the page's own /hit request, and readers are counted per device – an open tab sends a random id it keeps in localStorage on the JSON polls it already makes, so two devices on one WiFi count as two. What reaches the collector is a salted hash, held in memory for three minutes, with an address as the fallback for a browser that keeps no storage. And nothing is written to disk.

Response times and the speed test: Response times come from the access log. The speed test runs four times a day against Cloudflare's edge, since Ookla's own CLI does not work here, so the script uses curl with a browser user agent.

A weak power supply: The collector also reads vcgencmd get_throttled for undervoltage and throttling flags, so a weak charger shows up on the page.

The live page itself

Four files with no framework and no build step. index.html, style.css, app.js and a one line beacon.js that reports the page load come to about 14 KB gzipped in total.

The icons are one inline SVG sprite with 26 symbols, so a page with this many small labels still makes no extra requests. By the way, I printed the numbers in full with separators, so a visitor count reads 1,247 rather than 1.2k.

There are no cookies and no third-party requests, and a default-src 'self' policy keeps it that way. The one identifier anywhere is the random device id above, and it never leaves the browser except as a salted hash in memory. For my other sites I use the analytics setup I run on a VPS, and this page needs none of that.

The WiFi link, measured

The Pi is a client on my network rather than a server, so the WiFi link is the slowest part of the setup.

The link runs on 5 GHz, channel 36, at a reported 270 Mbit/s, but the real throughput measures around 43 Mbps against Cloudflare's edge.
Upload matters more than download here, because the visitors pull the page from my house, so the upload side of the line is what everyone shares.
Power save can add latency, and NetworkManager reports it as default on this setup, and it is the first setting I would check if SSH felt sluggish.

What it costs to run

Between 3-5 W of electricity.
Around 250 MB of the 906 MB of RAM the OS can see, with the web server, the collector and the tunnel running.
Under 2% CPU while idle, and about a millisecond for Caddy to hand over the page at the median.
43 Mbps of a 200 Mbps fiber line, which is the WiFi link rather than the board.

By the way, could a Zero 2 W do the same job?

What I learned

Memory is what fills first: Caddy and cloudflared both kept growing under load, on a board with 906 MB. The caps are what stop that from ending in an outage.
Caching made the biggest difference: The page is answered at the edge now, so the Pi stopped handing the same bytes to every visitor, and the size of the audience stopped mattering as much.
The WiFi link is the slowest part: Slower than the board and slower than the line it sits on.
The SD card fails first: Keeping the writes in RAM is the one habit I would keep from this project.
Counting readers without collecting anything was the hard half: Reading /proc is a solved problem.

The page is live at pi.deepakness.com, and it updates every 10 seconds. The Caddyfile, the collector, the units, and the watchdog are on GitHub in a public repo.

Overall, it was a super fun project and I loved every bit of it.

Hetzner's dedicated server is cheaper than VPS

2026-09-12T05:27:50Z

I just noticed that Hetzner's dedicated servers, also known as bare metal, are cheaper than their VPS plans. Here's a quick comparison from both pricing pages, with prices excluding VAT.

Server Type	Pricing	CPU	RAM	Storage
VPS (CPX42)	€69.49/mo	8 vCPU	16 GB	320 GB SSD
Dedicated Machine (AX41)	€59.00/mo	6 cores/12 threads	64 GB	2 × 512 GB NVMe

So the AX41 gives 4x the RAM and 3x the storage for €10.49 less every month, and it has no setup fee. The CPX42 also ends up at €69.99 in the console once the IPv4 address is added.

Hetzner dedicated server pricing:

Hetzner VPS pricing:

The usual worry with bare metal is the extra setup work, and it's the same short checklist either way. Put the admin panels behind Tailscale, keep the websites public through Cloudflare, and run off-site backups with rsync or maybe BackBlaze, and you're done.

And if you're okay with going one step further you can even get a physical device and host everything there. But it's a bit extreme as stable internet and even electricity availability might be challenging for different locations.

I am not immediately migrating to it, but it should be pretty fun setting up. And a lot of learning experiences.

Will explore this soon.

Fixing Threads API publishing errors

2026-09-10T18:29:18Z

I have been adding Threads support to my own posting setup, and the Threads API kept failing with an error that looked like a permissions problem.

The first one was code 100, error_subcode 33, "Object with ID ... does not exist", on every single post. The ID in that message is the user_id that comes back from the OAuth token exchange, and the Graph API doesn't accept it as a publishing target. I wasted time re-authorizing the account and toggling permissions because the message says "missing permissions", but that wording is boilerplate that shows up on code 100 whatever the token actually grants. What worked was asking Meta who the token belongs to and publishing as that.

curl "https://graph.threads.net/v1.0/me?fields=id,username&access_token=$TOKEN"

The id from /me published fine on the first try, and since then I refresh the stored id on every publish so an old row repairs itself.

Then a threaded post with an image failed with code 1, error_subcode 2207052, "Media download has failed". Meta downloads the image_url on their side when the container is created, and here their crawler couldn't fetch it. I pulled both files out of storage to compare and they were byte-identical, same MD5, one failed and the other published seconds later, so it's a flake and not something wrong with the image. I made the container creation retry with a freshly signed URL, and left that failure retryable so a scheduled post tries again instead of parking as failed.

The truncated error text never told me any of this. The full response body did, and the error_subcode is what showed me which of the two I was looking at.

MacBook looking at itself in a mirror to self-improve

2026-09-12T00:00:00Z

Came across this rather interesting and funny picture in a post on X where an AI agent on a MacBook is using its webcam to look at its screen in a mirror to improve itself. As explained in the X post, it's working on improving the AMD Radeon chip support in Omarchy Linux.

Someone asks Grok in a reply below why this approach is better than taking screenshots and then looking at them to improve itself, and Grok replies:

Screenshots grab the compositor or DRM framebuffer. The path to the actual panel runs through the GPU display engine, timings, gamma LUTs and scanout hardware. AMD driver bugs frequently break only that stage (black screens, color shifts, tearing, freezes) while software readback still succeeds. The webcam+mirror sees the real photons.

I had no idea about this.

Very interesting, actually.

Update:

Just saw this update from Justin on this that the MacBook with Omarchy on it fixed its external monitor support for AMD Radeon chips by looking at the screen via the webcam.

Fascinating!

DeepSeek v4.1 Flash is here with a new price

2026-09-09T23:50:01Z

The new DeepSeek v4.1 Flash model is here and the two most important things about the model is that it has native vision capabilities, and it's significantly cheaper after the price hike last month. I have updated the pricing on the DeepSeek peak/off-peak clock page already.

Another interesting thing is, as you see above, the new v4.1 Flash has surpassed the existing v4 Pro on all metrics so from now on all requests to the Pro model will be routed to the new Flash model.

Interesting!

About the new price, here's the price table and comparison with the old pricing (all prices in per million tokens):

Metric	Off-peak, old	Off-peak, new	Peak, old	Peak, new	Reduction
Input, cache hit	$0.007	$0.003	$0.014	$0.006	57.1%
Input, cache miss	$0.22	$0.15	$0.44	$0.30	31.8%
Output	$0.66	$0.60	$1.32	$1.20	9.1%

I used the model a lot yesterday, and it's visible that it's significantly better than other models, and it just has a better taste. I tested it for writing, and it already writes better than other DeepSeek models and even more natural than Claude or GPT models.

Good job, DeepSeek! And thank you.

Ubuntu 26.04 on Mid-2014 MacBook Pro – it finally works

2026-09-09T06:50:01Z

After Fedora 44 and Linux Mint, I wiped the old MacBook Pro and installed Ubuntu 26.04.1 LTS on it. Wi-Fi, camera, mic, speakers, and fans all work now. Here's everything I had to fix, in case I need to redo it.

Wi-Fi didn't work out of the box. The BCM4360 chip needs the proprietary wl driver because b43 grabs the card first.

# Preferred
sudo apt install broadcom-sta-dkms
sudo dkms autoinstall

# Or from the .deb (dpkg skips dependencies, fix them after)
wget http://mirrors.kernel.org/ubuntu/pool/restricted/b/broadcom-sta/broadcom-sta-dkms_6.30.223.271-29ubuntu1_amd64.deb
sudo dpkg -i broadcom-sta-dkms_6.30.223.271-29ubuntu1_amd64.deb
sudo apt --fix-broken install

# Either way
sudo update-initramfs -u
sudo modprobe wl
ip link show | grep wl

I used the .deb from a Linux Mint forum thread, and it broke until --fix-broken install fixed it. The update-initramfs -u step is required for the b43 blacklists to apply at boot.

The FaceTime HD camera needs three pieces, the DKMS module, the firmware, and the sensor files.

sudo apt install dkms build-essential linux-headers-$(uname -r) git curl
git clone https://github.com/patjak/bcwc_pcie.git
cd bcwc_pcie
sudo dkms add .
sudo dkms build facetimehd/0.7.0.1
sudo dkms install facetimehd/0.7.0.1
sudo depmod
sudo modprobe facetimehd
echo facetimehd | sudo tee -a /etc/modules > /dev/null
ls /dev/video0

Check cat dkms.conf | grep PACKAGE_VERSION first, because the repo says 0.7.0.1 while guides still say 0.2.

git clone https://github.com/patjak/facetimehd-firmware.git
cd facetimehd-firmware
make            # fails on the assistant hash, this is expected
sudo make install

mkdir -p /tmp/facetime-fw && cd /tmp/facetime-fw
for f in 9112 1771 1871 1874; do
  curl -fsSL -o ${f}_01XX.dat \
    https://raw.githubusercontent.com/eudoxos/skoly/main/tweaks/macbook-air/firmware/${f}_01XX.dat
done
sudo cp *.dat /usr/lib/firmware/facetimehd/
sudo modprobe -r facetimehd && sudo modprobe facetimehd

The make failure is expected, and firmware.bin still extracts fine. After the sensor files, dmesg | grep facetimehd should show no more failed with error -2 lines.

For the fans, mbpfan with the default config is enough.

sudo apt install -y mbpfan
sudo systemctl status mbpfan
cat /sys/devices/platform/applesmc.768/fan*_input

The fans spike to ~6000 RPM during install, then settle back to ~2000 RPM.

That's it.

On a fresh install, the order is apt update/upgrade, Wi-Fi, camera, mbpfan, reboot, and check Wi-Fi, /dev/video0, and mbpfan.

SharePDF gets its first intro video

2026-09-09T01:40:24Z

I was procrastinating this for a long time but finally spent some time and created the very first intro video for SharePDF, and now it's live on SharePDF YouTube channel. You can also watch it here though:

Yes, that's me. But please ignore the low-effort thumbnail, I will make it better later.

I am planning to create at least one video per week from now on, and will create short videos as well. I can create videos for individual features that the app has.

Still have to do a lot of thinking to create a more robust long-term video strategy.

All the best to me!

Why AI will never be able to take over humans

2026-09-05T01:45:49Z

AI is capable of doing many things better than humans, but it doesn't have human-like curiosity. AI does not wonder on its own and answers only when asked.

So I think AI will never be able to take over humans because without genuine curiosity, it just remains a powerful tool.

Two new improvements in my work setup recently

2026-09-04T13:30:47Z

In the last few days, I have adopted two new changes in my work setup:

Started using Herdr with Ghostty, and
Turned on More Space display scaling option on macOS

Earlier, I was hopping between different apps like Claude Code, Cursor, etc. and wasn't using CLI coding harnesses a lot. But my productivity has significantly increased ever since I started using this Herdr terminal multiplexer via the Ghostty terminal. And I even went a step ahead and unbound certain keybindings from Ghostty and bound them inside Herder, and now opening tabs, splitting panes, and other things are much easier.

About the other thing, as you see above, I turned on the "More Space" display scaling option on my macOS device. Initially, it took some time to adjust, but now I don't even need my second display as I can see much more information on the main display itself. And it's less distracting than using the second screen.

That's it.

These two small changes recently have significantly improved my productivity.

I used 28 different OpenCode models last month

2026-09-01T00:22:10Z

I didn't renew my Claude Max subscription after it ended last month, and decided to use OpenCode for some time. And it's been more than ~15 days of using OpenCode models, and I've missed Claude models only a few times.

From OpenCode's usage tab, I have used 28 different models last month, as you see in the screenshot.

Among all the models you see in the screenshot, only a few stood out.

DeepSeek V4 Flash (0731): Love this model for simpler tasks like doing some research from multiple different sources and creating interactive HTML pages for better visualization, fixing quick UI bugs, etc. It's very fast and mostly accurate for these tasks.
DeepSeek V4 Pro (0813): This model is great for a lot of tasks, and I have used this for fixing some serious bugs on SharePDF, building websites, brainstorming, etc.
GLM 5.3 Flash: Been using this model a lot since it came, and it's a great one for UI and research. The only issue is that it's very slow in OpenCode Go, so I use it for low-priority tasks, and sometimes I even keep it running overnight.
DeepSeek V4 Flash Vision Exp: While I use an extension in Pi that uses another model for vision, I found this model to be great at browser automation tasks. I used it a lot via the Orca app for automating stuff in my browser, and it's good and fast too.
Mimo v2.5: Sometimes I use this model for really simple, low-priority tasks, and it's good at that. But don't use it for anything else.

Apart from these, most models you see in the chart above are only for trying and testing. I'm mostly using these 5 models via my OpenCode Go subscription.

Most of the time I use these in the Pi coding agent via my new Herdr + Ghostty setup, but sometimes also using Pi inside the Orca app for browser use tasks. I'm rarely using OpenCode models inside the OpenCode harness actually.

Playing with the Grok bot

2026-08-31T17:31:50Z

Yesterday, I downloaded and installed the new Grok bot and playing with it to see how it can fit in my workflow. I have connected it to my existing SuperGrok subscription and so far it's working fine.

As of now, I have set up 3 bots that do the following:

Emails bot: reads my emails twice a day, gives me a summary and reminds me of something important that needs to be done.
AI Research bot: researches for AI related updates from the internet and sends me a summary twice a week.
Ticky bot: manages my to-do list via Notion and email, sends an email every morning about today's and other upcoming tasks.

I know this very basic and people must be using it for more complex tasks, but I'm just exploring and learning about it. I haven't yet seen any tutorials about it, but will do and improve my setup.

By the way, I'm pretty impressed by it so far.

Lastly, the different pricing plans and different login options using Grok and Cursor make it very very confusing. I hope they solve it quickly.

Unbinding Ghostty's Cmd keys and binding them in Herdr

2026-08-30T14:32:34Z

Since setting up Herdr inside Ghostty, the same actions had two shortcuts, Cmd+T for a Ghostty tab and Ctrl+B C for a Herdr tab, and that made things a bit confusing and then I had to keep using my mouse for everything in Herdr. But Oron Ben suggested something on X and that clicked, I then followed his write-up to unbound the Cmd keys in Ghostty and bound the same keys directly in Herdr.

Now, Ghostty passes the keypress through to the terminal and Herdr answers it, no prefix and no escape-code translation.

Shortcut	Before (Ghostty)	Now (Herdr)
`Cmd+T`	new tab	new tab
`Cmd+W`	close tab	close pane
`Cmd+D`	split right	split pane vertically
`Cmd+Shift+D`	split down	split pane horizontally
`Cmd+]` & `Cmd+[`	focus next and previous split	cycle next and previous pane
`Cmd+Shift+]` & `Cmd+Shift+[`	next and previous tab	next and previous tab
`Cmd+1..9`	jump to tab	switch workspace
`Alt+1..9`	types special characters	switch tab

Ghostty keeps everything else, Cmd+N for a new window, Cmd+C / Cmd+V for copy and paste, search, and font size. And Herdr's Ctrl+B prefix mode keeps working as a fallback, with Ctrl+B ? showing the help panel.

I also created a short video to show how easier it is to navigate inside Herdr using these keyboard shortcuts.

The Ghostty side lives in the same config file my cmux setup already used at ~/Library/Application Support/com.mitchellh.ghostty/config.ghostty, symlinked from ~/.config/ghostty/config.

macos-option-as-alt = true

keybind = cmd+t=unbind
keybind = cmd+w=unbind
keybind = cmd+d=unbind
keybind = cmd+shift+d=unbind
keybind = cmd+[=unbind
keybind = cmd+]=unbind
keybind = cmd+shift+[=unbind
keybind = cmd+shift+]=unbind
keybind = cmd+1=unbind
keybind = cmd+digit_1=unbind
keybind = cmd+2=unbind
keybind = cmd+digit_2=unbind
keybind = cmd+3=unbind
keybind = cmd+digit_3=unbind
keybind = cmd+4=unbind
keybind = cmd+digit_4=unbind
keybind = cmd+5=unbind
keybind = cmd+digit_5=unbind
keybind = cmd+6=unbind
keybind = cmd+digit_6=unbind
keybind = cmd+7=unbind
keybind = cmd+digit_7=unbind
keybind = cmd+8=unbind
keybind = cmd+digit_8=unbind
keybind = cmd+9=unbind
keybind = cmd+digit_9=unbind

Ghostty binds both cmd+1 and cmd+digit_1 by default, 1 matches the character and digit_1 the physical key, so both lines are needed for every digit. You can check with ghostty +show-config --default | grep goto_tab.

The Herdr side goes into ~/.config/herdr/config.toml:

[keys]
new_tab = "cmd+t"
close_pane = "cmd+w"
split_vertical = "cmd+d"
split_horizontal = "cmd+shift+d"
cycle_pane_next = "cmd+]"
cycle_pane_previous = "cmd+["
next_tab = "cmd+shift+]"
previous_tab = "cmd+shift+["
switch_workspace = "cmd+1..9"
switch_tab = "alt+1..9"

herdr config check validates the TOML and herdr server reload-config applies it to the running server without a restart. For Alt to work at all, macos-option-as-alt = true is required in Ghostty, otherwise Option types special characters.

So far, I'm loving the setup.

Using OpenCode Go models in ZCode harness

2026-08-28T16:28:56Z

I subscribe to OpenCode Go for its open coding models, and the same models work inside ZCode too, because ZCode accepts any custom provider that speaks the OpenAI or Anthropic protocol. Same trick as when I pointed OpenCode itself at NVIDIA's models a while back.

The setup is just a few fields in ZCode's Model settings. Click "Add provider", name it OpenCode, and fill these in:

Base URL:   https://opencode.ai/zen/go/v1
API format: Chat completions (/chat/completions)
API key:    your key from opencode.ai/auth

Then click "Add model" and type the model IDs you want, like glm-5.3-flash or deepseek-v4-flash, and enable the provider.

One catch is that Go splits its catalog across two formats. The Qwen and MiniMax models are only served through the Anthropic messages format, so for those add a second provider with the same key, set the format to Anthropic messages (/v1/messages), and use https://opencode.ai/zen/go as the base URL. ZCode appends /v1/messages itself. Grok 4.6 and GPT 5.6 Luna don't work at all, they only exist on OpenAI's Responses API, which ZCode doesn't speak.

Once a model responds, open its edit dialog and set the real context window, max output tokens, and input types. The input types matter most, that's how ZCode knows glm-5.3-flash accepts screenshots while deepseek-v4-flash is text-only.

The full live model list stays at https://opencode.ai/zen/go/v1/models, so I just paste a new ID into ZCode whenever a new model shows up. Go's limits are dollar-based, $12 per 5 hours, $30 weekly, $60 monthly, so cheaper models like deepseek-v4-flash stretch the plan much further. And if you are about to subscribe, use a referral link, the $5 reward cuts the 5-hour limit by up to 41%.

Omarchy is the best Linux distro for old laptops

2026-08-25T13:54:13Z

I installed Omarchy on my decade-old MacBook Pro this week, and after distro-hopping through Fedora and Mint on the same machine, I am convinced this is the best Linux distro you can put on old hardware. Fedora needed a lot of surgery just to get Wi-Fi and the webcam working, and Mint managed to break its own Wi-Fi driver on the first update, but Omarchy simply installed cleanly, booted fast, and everything just worked.

It's DHH's Arch-based distribution with the Hyprland tiling window manager and the Quickshell desktop shell, all configured out of the box. It ships with everything a developer needs on day one, from Neovim to Chromium, Obsidian to LibreOffice, and even Kdenlive and OBS Studio. But what surprised me most is how light it runs, and a laptop from 2014 now boots in seconds and apps open instantly. Yes, faster than others I tried.

It also helps that the Omarchy community is thriving. The project crossed 30,000 stars on GitHub within a year, and there is now an Omacom foundation backing it. I already love this distro enough to have been collecting Omarchy themes, setups, and resources in one place for a while.

I took a lot of photos and screenshots during the install, and here they are.

Beautiful, aren't they?

Linux Mint Wi-Fi and failed update fix on 2014 MacBook Pro

2026-08-25T05:29:20Z

After the Fedora 44 test, I wiped the old MacBook Pro and installed Linux Mint 22 on it, and accepted the Broadcom driver installation that the Driver Manager popup showed. But then the first system update failed, so I spent some time and finally got it fixed.

The update pulled in the HWE kernel 7.0.0-30, and DKMS couldn't rebuild the proprietary wl driver for it, so linux-headers-7.0.0-30-generic, linux-headers-generic-hwe-24.04, linux-generic-hwe-24.04, and linux-image-7.0.0-30-generic were left unconfigured. By the way, the Wi-Fi was working on the old 6.14 kernel.

Then, canonical patches wl 6.30.223.271 for every kernel bump, and while 23ubuntu1.2 fixed 6.17, only 23ubuntu1.3 in noble-proposed has the linux-7.0 fix. I booted into 6.14, and ran this.

echo 'deb http://archive.ubuntu.com/ubuntu noble-proposed restricted' | sudo tee /etc/apt/sources.list.d/noble-proposed.list
sudo apt update
sudo apt install broadcom-sta-dkms=6.30.223.271-23ubuntu1.3
sudo dpkg --configure -a
sudo rm /etc/apt/sources.list.d/noble-proposed.list
sudo apt update
sudo reboot

The driver install builds wl for 7.0, and dpkg --configure -a finishes the stuck packages. After reboot, uname -r showed 7.0.0-30-generic, lsmod | grep wl showed the module loaded, and nmcli device status showed wlp2s0 connected on 5 GHz.

The locale warnings in the update output went away after sudo dpkg-reconfigure locales with en_IN.UTF-8 selected, because en_IN.ISO8859-1 was never generated on the system. And for next time, b43 doesn't support this BCM4360's AC revision, installing the driver after the update wouldn't have helped either, and after any future kernel update the same check applies.

Can look at apt-cache policy broadcom-sta-dkms for a newer version in noble-proposed.

Fedora 44 Wi-Fi and Webcam fix on Mid-2014 MacBook Pro

2026-08-24T17:20:00Z

I installed Fedora 44 on the $100 MacBook Pro I bought recently just to test Linux on it, and Wi-Fi simply didn't exist – no network, no wlan interface, and literally nothing in NetworkManager. And after spending a lot of time, here's the short version of how it was fixed.

I discovered, the MacBook has a Broadcom BCM4360 Wi-Fi chip 14e4:43a0 and the open-source b43 driver that Fedora loads by default doesn't support this 802.11ac chip, so the card sits there unable to do anything. It needs the proprietary broadcom-wl driver, which lives in the RPM Fusion nonfree repo, and obviously doesn't automatically get installed.

So the fix starts with enabling the nonfree repo and installing the driver.

sudo dnf install https://mirrors.rpmfusion.org/nonfree/fedora/rpmfusion-nonfree-release-$(rpm -E %fedora).noarch.rpm

sudo dnf install akmod-wl kernel-devel-$(uname -r)

The akmod-wl package builds the wl kernel module for your running kernel and rebuilds it automatically after future kernel updates. Next, needed to stop the open drivers from claiming the card by creating /etc/modprobe.d/broadcom-wl.conf with these lines.

blacklist b43
blacklist b43legacy
blacklist brcmsmac
blacklist ssb
blacklist bcma
blacklist bcm43xx

And make sure wl loads at boot by putting a single line in /etc/modules-load.d/wl.conf.

wl

Then build the module and reboot.

sudo akmods
sudo reboot

After the reboot Wi-Fi showed up in the toolbar and in GNOME settings and connected without any issues. By the way, USB tethering via my Android device got me through the setup, because that was the only way to use internet on the Fedora device.

Apart from this, the webcam also didn't work and needed more work. This MacBook has a Broadcom 720p FaceTime HD camera (14e4:1570) with no open driver at all, so /dev/video0 never appears. The fix has two parts, and I also installed lm_sensors along the way to read fan speeds and temperatures.

First the driver. It's out-of-tree and built via DKMS, which already has kernel-devel available from the Wi-Fi setup.

sudo dnf install dkms

git clone --depth 1 https://github.com/patjak/bcwc_pcie.git
sudo cp -r bcwc_pcie /usr/src/facetimehd-0.7.0.1
sudo dkms add facetimehd/0.7.0.1
sudo dkms build facetimehd/0.7.0.1
sudo dkms install facetimehd/0.7.0.1

Then the firmware. The camera needs Apple's proprietary firmware extracted from the macOS 10.12.6 update, and there's a script that pulls only the needed chunks from Apple's CDN and verifies them by SHA256.

git clone --depth 1 https://github.com/patjak/facetimehd-firmware.git
cd facetimehd-firmware
sudo ./facetimehd-firmware-install.sh

The script drops firmware.bin and eleven sensor calibration files into /usr/lib/firmware/facetimehd/. Then load the module and the camera appears.

sudo modprobe facetimehd
ls /dev/video0

I verified it with a one-frame ffmpeg capture, which produced a proper 122 KB JPEG. To make it persistent across reboots, add facetimehd to /etc/modules-load.d/facetimehd.conf and /etc/dracut.conf.d/facetimehd.conf, then rebuild the initramfs.

echo "facetimehd" | sudo tee /etc/modules-load.d/facetimehd.conf
echo 'add_drivers+=" facetimehd "' | sudo tee /etc/dracut.conf.d/facetimehd.conf
sudo dracut --force

DKMS rebuilds the camera module automatically on kernel updates, the same way akmods handles the Wi-Fi driver. Secure Boot is a non-issue on this machine since Apple's EFI doesn't support it, so the unsigned modules load without any key enrollment.

Get 10% off Z.ai GLM coding with a referral link

2026-08-22T20:31:30Z

Z.ai runs an "Invite Friends, Get Credits" campaign, and if you sign up to the GLM Coding plan through my Z.ai referral link, you get a 10% instant discount on your first subscription. The discount is applied automatically at checkout, so there's no coupon code to remember.

Here are the conditions from the official campaign rules.

The discount works for new accounts and for existing accounts with no paid subscription history.
It applies to the first GLM Coding order only. Renewals, upgrades, and downgrades are not eligible.
It can't be stacked with other similar first-order discounts.

On my side, if you subscribe through the link, I earn credits worth 10% of what you pay, and up to 20% with their tiered bonus. It's a win-win, similar to the OpenCode referral reward I wrote about earlier.

That's it.

Find all subdomains of a domain with crt.name

2026-08-21T23:14:19Z

Came across this post on X that shared a trick to find all subdomains of a domain. You add your domain in the URL below, visit it in your browser, and it shows you a bunch of subdomains:

https://crt.name/v1/search?apex=YOUR_DOMAIN

Just replace YOUR_DOMAIN with a domain and it lists every subdomain it has on file. The index is pre-built, and as their website explains, the data is assembled from multiple archives. Certificate transparency logs, retired CT logs replayed from the Internet Archive, Common Crawl, ICANN CZDS zone files, ProjectDiscovery Chaos, HaGeZi blocklists, and a prober that checks common hostnames against known apexes.

Since it aggregates so many sources, the results lean toward anything that ever existed for that apex. During my testing, most of the subdomains were either old, dead, or even something that I never set up in the first place.

2026: The year of Linux Desktops

2026-08-21T16:48:21Z

Welcome to the year of Linux desktops, 2026!

DHH has truly created a revolution with his Linux distro Omarchy. Just over a year after the initial launch, the Omarchy ISO is now being downloaded almost 5,000 times every day.

Recently, the Omacom foundation was launched with a whopping $8 million in funds, and the following 8 patrons contributed $1 million each for the cause.

Legendary folks, no?

I used Linux for 5–6 years, then went back to Windows and am currently using macOS, but I have never been more excited to try Linux again. I watched DHH's new video. The new Omarchy Quattro looks amazing. And the next chance I get to upgrade my setup, I am moving to Linux once and for all.

Chrome Web Store revises limits on extensions

2026-08-20T22:31:32Z

Recently, Chrome Web Store has revised its limits on number of extensions you can publish to the Web Store. I don't know what the limit was earlier, but now, for new accounts it starts from the limit of 2 published extensions as explained on this docs page. You can request an increase when you hit the limit of 2, and then limits increased to 4 or more, as you progress. Right now, I'm at this limit of 10 published extensions as you see in the screenshot.

And I see the below message in a popup when I click on this 8/10 limits button.

Neither in their docs and nor in the developer dashboard it's mentioned if they will further entertain my request to increase limits from 10 to more. But I'm about to publish a few extensions so let's see how it goes.

I will keep this page updated as I learn more.

Managing AI agent workspaces with Herdr

2026-08-20T19:38:13Z

After configuring cmux and trying out Kero, I've been testing herdr as a terminal workspace manager built around coding agents. Each project gets its own workspace with tabs and panes, and herdr remembers which agent session lives where.

Everything sits in plain files under ~/.config/herdr/.

~/.config/herdr/config.toml    settings and theme
~/.config/herdr/session.json   workspaces, tabs, panes, agent sessions
~/.config/herdr/herdr.log      plus herdr-server.log and herdr-client.log

My herdr config is small, a gruvbox UI theme with agent labels on pane borders.

[ui]
status_indicators = "symbols"
show_agent_labels_on_pane_borders = true

[theme]
name = "gruvbox"
auto_switch = false

[ui.toast]
delivery = "terminal"

I run herdr as a TUI inside the Ghostty terminal. Ghostty reads the same config file my cmux setup already used at ~/.config/ghostty/config, so the terminal look carried over as-is. I only changed the theme to Gruvbox Dark and left everything else default. Here's how it looks currently, but obviously I will keep improving it:

Herdr detects the agents in each pane and shows their state, working, blocked, or idle, right in the sidebar. And it's all just so convenient to use and manage.

Everything is saved to session.json, so reopening herdr brings back every workspace exactly as it was, which was the one thing I missed in Kero and it somewhat worked in cmux but wasn't reliable. I'm still testing it alongside cmux, but it's looking like it could become my permanent setup, eventually.

Apart from this, the most clear, to the point, and convincing video I ever watched about herdr is this one from Jilles. This video is the reason I installed and started using herdr.

Don't send report, send prompt instead

2026-08-20T08:00:31Z

Don't send me the report, just send me the prompt.

This post on X from Naval made me laugh that basically points out the irony when people use AI for everything.

Setting up Hetzner Qwen3.8-27B in the Pi agent

2026-08-19T04:47:37Z

I added the Hetzner Inference API as a provider in my Pi agent, the same way I set up NVIDIA models in OpenCode. Hetzner runs an OpenAI-compatible REST API at inference.hetzner.com serving open-weight Qwen models. To get an API token you log in to experiments.hetzner.com and create one from the Inference app there. The service is free while it stays experimental, but you still have to add a credit card to the account before it lets you generate a token. The docs are at Hetzner's Inference API page linked above.

Custom providers in pi live in ~/.pi/agent/models.json and the model ID to use is Qwen3.8-27B, and you can always check the live model list with:

curl -s https://inference.hetzner.com/api/v1/models \
  -H "Authorization: Bearer <YOUR_TOKEN>"

Here is the full provider config:

{
  "providers": {
    "hetzner": {
      "baseUrl": "https://inference.hetzner.com/api/v1",
      "api": "openai-completions",
      "apiKey": "<YOUR_TOKEN>",
      "compat": {
        "supportsDeveloperRole": false,
        "supportsReasoningEffort": false
      },
      "models": [
        {
          "id": "Qwen3.8-27B",
          "name": "Qwen3.8 27B (Hetzner)",
          "reasoning": true,
          "input": ["text", "image"],
          "contextWindow": 262144,
          "cost": { "input": 0, "output": 0, "cacheRead": 0, "cacheWrite": 0 }
        }
      ]
    }
  }
}

The compat flags tell pi to send a plain system message instead of the developer role and to skip the reasoning_effort field, which the Qwen server does not understand. reasoning: true enables thinking mode, input allows text and image messages, and the context window is 262k tokens.

No restart needed. Open /model inside pi and the model appears as Qwen3.8 27B (Hetzner), since the file reloads whenever you open the model picker. Keep models.json readable only by your user because the key sits in plain text. Rate limits are 10 requests and 100k output tokens per minute, and going over returns HTTP 429.

A page for personal websites I like

2026-08-18T02:49:36Z

I added a new page on my site for personal websites I like. Each site gets a card with a snapshot of its homepage, taken the day the site was added, so the screenshot may not match what the site looks like today. The card also shows the site's dominant background color and how heavy the homepage's code is, meaning the HTML, CSS, JavaScript and fonts it loads, with images and video excluded.

The page sorts the cards by name by default, with options to sort by newest or oldest added, plus a filter for the code weight bands. Cards past the second row are deferred with content-visibility: auto, so the page stays fast as the collection grows.

I will keep adding interesting personal websites as I discover more.

A clock for DeepSeek's time-of-day pricing

2026-08-22T00:00:00Z

DeepSeek moved its API rates to time-of-day pricing with the V4 Pro release. The cheap hours cost exactly half of the expensive ones, and the boundaries are fixed in UTC. Anywhere else in the world that means converting in your head every single time, so I built a DeepSeek peak/off-peak pricing clock page that shows which half of the day I'm in right now.

By the way, you can check the clock here.

The page shows whether it's cheap or expensive right now, how long the window lasts, when it flips next in local time, and what both models cost either way. In IST the cheap stretch runs from 3:30 PM to 6:30 AM, with expensive blocks at 6:30–9:30 AM and 11:30 AM–3:30 PM.

I queue my non-urgent jobs during the cheap half and the bill drops by 50%. I've been running V4 Pro as my daily model since an earlier note, so the clock has been earning its keep. The rates come straight from the official pricing page.

Update: Sat Aug 22, 2026

DeepSeek changed the weekend rules barely a week after launching the clock. From 00:00 Beijing time on August 23, 2026, Saturdays and Sundays (Beijing time) are billed at the off-peak rate all day, and the weekday windows stay exactly as they were. In IST the cheap stretch now runs non-stop from Friday 3:30 PM to Monday 6:30 AM. The clock page handles the weekend schedule automatically, so it's still the one URL to keep open.

Trying the New DeepSeek Harness

2026-08-16T12:48:37Z

After building such great Pro and Flash models, DeepSeek has decided to step into the harness game as well. Their harness is based on this philosophy of "everything is a plugin", much like the Pi coding agent. I have been using Pi with DeepSeek models for months now, so I was curious to see DeepSeek's own take on the idea.

All tech news and influencers are talking about the new DeepSeek harness, so I had to give it a try. And my experience so far is pretty good to be honest. In this post, I will explain how I installed and set up the harness for myself and what I liked and disliked about it.

What is the DeepSeek Harness?

The DeepSeek Harness or dsh is an open-source agent harness from DeepSeek AI, and that tagline is not just marketing – every part of the product, from the model adapter to the session log to the agent loop itself, is a plugin. It runs on Cordis, so there is no core to patch. You swap a part by mounting another plugin beside it.

The agent can read and edit workspace files, run commands, delegate work to subagents, and keep a plan as it goes.

It is currently in developer preview, and the team is upfront about it in the repo README. It ships as a Web UI at http://127.0.0.1:3080, but that is just one way to use it. There is also a headless mode and a Python SDK for programmatic use, though I did not use them this time.

Installing the DeepSeek Harness

As mentioned on their GitHub repo page, using the npx @deepseek-ai/dsh web command in the terminal is the best way to quickly install and use the harness. But it didn't work for me and threw the following errors.

I then quickly cloned the repo and ran it from the source with the following commands.

git clone https://github.com/deepseek-ai/deepseek-harness.git
cd deepseek-harness
pnpm install
pnpm run build
pnpm dsh web

It's straightforward, and the process takes just over a minute. You get this http://127.0.0.1:3080 URL in the terminal that I opened in the browser. It showed me an "internal testing warning" popup and then asked me to provide the official DeepSeek API key or configure later, as you see.

Setting up a provider

My first impression was that this only works with the official DeepSeek provider, but it works with almost all major providers, and you can add custom ones for any OpenAI-compatible endpoint. Everything lives under Settings > Models.

I added my OpenCode Go API key as you see above, and everything was set to start using OpenCode models inside the harness.

I already use DeepSeek v4 Pro and Flash through my OpenCode Go subscription inside Pi, so the harness now runs the same models with the same thinking levels. The key itself lands in ~/.dsh/.credentials.yaml, while the settings file keeps only a reference to it – the UI never shows the secret back. My ~/.dsh/settings.yaml looks like this.

llm-pi-ai:
  providers:
    opencode-go:
      apiKeyEnv: OPENCODE_GO_API_KEY
agent-default-model:
  provider: opencode-go
  model: deepseek-v4-pro
  reasoningEffort: max

The llm-pi-ai key at the top is a fun detail. The generic provider adapter is built on pi-ai, the model-provider library from the same team behind Pi. So the harness and my favorite terminal agent share more than just the plugin philosophy.

Model changes apply on the next request without restarting the server.

Using the DeepSeek Harness

After I added a local folder (they call it a workspace), honestly, it felt like I'm using the Codex app or ChatGPT web interface. All sessions are on the left side, and you can easily switch among them across different projects.

I really liked the UI and UX.

The first real task I gave it was a deep read-only audit of this very website's repo. I asked it to go through every single line of code, from all perspectives, and give me a brief report. It read my AGENTS.md file first, so all my site rules were in the conversation. Then it split the entire audit into six parallel subagents. One took scripts/, another _data/, one went through all 161 blog posts, another all 491 raw notes, and the rest took templates, CSS, and the top-level content pages.

And here is the part I really liked. Each subagent got its own session, and the dropdown at the top showed me exactly how many were working and the progress on each of them.

Apart from the subagents, I also loved the live stats at the bottom – tok/sec, cache hit rate, tool calls, turns, steps. None of it is necessary, but it makes the whole session feel transparent.

There is also a Trajectory tab for each session that shows the whole session as a timeline – every turn, step, tool call, and nested sub-tool call, each with its token usage and how long it took. Clicking a request opens its input, output, and timing details. It is the most transparent agent UI I have used.

It also felt safe. Everything ran inside the workspace, and the UI asked before anything that needed approval.

Session modes

The harness ships with four session modes, and you pick one when you start a session. A session's mode is fixed at creation – you cannot switch it mid-session, so a different mode means starting a new session.

Standard mode is the full coding agent – file editing, shell, file and web search, skills, planning, goals, subagents, and workflows. It is the default, and the mode I have been using for everything so far.
Code mode has all of Standard's capabilities, but the tools are presented through the Code Mode SDK. Instead of one tool call per action, the model writes a single TypeScript program against a generated SDK and runs it in one go – a sequence that would take five round trips becomes one.
Minimal mode is the opposite extreme, just two tools, a persistent bash shell and the str_replace_editor file editor. No search, no skills, no subagents, no planning. The smallest possible coding agent.
Creator mode is for making your own presets. It has all of Standard's capabilities plus a toolset that can inspect the running harness, experiment with plugins, and author presets. You can duplicate any built-in preset and make it yours, or let the agent draft a custom one for you in Creator mode.

The picker lives in the Agent presets section of the UI, and you can set a default mode for new sessions so you do not have to pick every time.

Things I like about the DeepSeek Harness

Everything is a plugin, for real. There is no core to patch, unlike most tools where you get whatever the vendor ships. It feels like Pi's philosophy with a polished GUI on top, and it is fully open source under MIT – no company decides what features I get.
The Web UI is clean. Sessions on the left, workspaces, and a Codex, ChatGPT or Gemini-like feel without giving up local files.
Subagents with live progress. The parallel audit would have taken forever in a single thread. Six agents, one dropdown, and live progress on each one.
Honest stats at the bottom. tok/sec, cache hit rate, tool calls, turns, steps. I wish more tools showed numbers like these.
Any provider you want. I plugged in OpenCode Go and was done. Keys stay in ~/.dsh/ on my machine.
Safe by default. A workspace-only sandbox plus approval prompts before risky operations.

Things I didn't like

The npx install did not work for me and I had to run it from source. Not a big deal, but the "one command" pitch should work.
Starting it is not instant. I have to launch the server from a terminal and then open the localhost URL in the browser before I can start working. It is fine once it is running, but it is more friction than just typing pi in the terminal.
It does not ping you when a task finishes. No sound, no notification – the harness just sits quietly in its browser tab, so for long-running tasks I keep switching back to check whether the agent is done yet.
DeepSeek models are text-only, so pasting an image into the harness does not work. In Pi I use a vision-handoff package that describes images with a separate vision model, and I have not found the equivalent setup in the harness yet.

Final thoughts

DeepSeek Harness is the GUI-shaped plugin agent I did not know I wanted. Pi stays my terminal agent for side projects and experiments, and Grok Build and Claude Code keep their roles in my AI stack – the harness is a strong addition, not a replacement yet.

After Pi and OMP, the plugin-first idea has clearly spread, and now DeepSeek ships their own take with real polish. I will keep using it for this site's work and update this post as I learn more.

If something breaks, GitHub Discussions and their Discord server are the places to report it.

DeepSeek models are better for writing

2026-08-14T09:56:59Z

I do many things using AI, but writing isn't one of them. However, I tried different models for writing and I feel both DeepSeek v4 Pro (0813) and DeepSeek v4 Flash (0731) models are much better at writing than others. Their writing style is more natural and very close to how I write, but the writing from Grok, GPT, and Claude models isn't that good.

Antigravity login bans for omp and Pi agent users

2026-08-13T19:21:52Z

I already wrote about Google banning users for using Antigravity with OpenClaw back in February this year. And it turns out the same applies to terminal coding agents like omp and Pi, which use your Google login to hit the Antigravity backend.

The omp maintainer was asked whether using it via OAuth is safe, and his answer was "You can get banned, I can't really give you any guarantee."

In fact, one user got banned 20 minutes after opening a Pro plan through the standard /login flow, another omp user got suspended a day after logging in, and a Pi user got banned after using Pi with Antigravity just once.

The reports were consistent enough that Pi's maintainer removed both the Antigravity and Gemini CLI providers from the project in April. In this Pi issue, a banned user was told point blank, "DO NOT use Pi with Google auth under any circumstances, if you want to use Gemini models you must get an API key from Google Cloud/Vertex".

Google's Antigravity terms call using third-party software with your Antigravity login a direct ToS breach. The first flag is probably recoverable through an appeal form, the second one is a permanent ban, and Google also killed the consumer Gemini CLI "Login with Google" option a few months ago.

I also made this mistake and was using both Antigravity and Claude Code models via omp, but thankfully people warned me when I shared about this on Reddit.

So... if you want to use Gemini models, use an AI Studio API key or Vertex AI instead. Otherwise, use the Antigravity CLI, it's not so bad.

How I embed videos in notes now

2026-08-13T16:42:55Z

Every video on this site now lives next to the note that uses it, the same way images do. I drop a video into the note folder, reference it with one shortcode line, and pnpm ready handles the rest – transcoding, thumbnail/poster, upload, and the player.

Drop the recording into the note folder, like content/raw/some-note/demo.mov
Reference the mp4 name in the note, even when the dropped file is a .mov

{% video "./demo.mp4" %}

Running pnpm ready transcodes the file to an optimized web-ready MP4 (H.264, yuv420p, faststart, crf 26, width capped at 1600px), extracts a poster frame from about 25% in as demo-poster.webp, records state in _data/cache/video-cache.json, and uploads the mp4 and poster to R2 under raw/some-note/ folder.

The above shortcode attaches the poster automatically, the player loads nothing until someone presses play, and nothing is fetched from a third party. I used to do this by hand and wrote down the ffmpeg commands earlier, but now it's all automatic.

Also, a few things worth knowing:

If I place my own demo-poster.webp next to the video, the pipeline keeps it instead of generating one
Videos are gitignored like images, so recordings never reach the repository
To reprocess a video, run node scripts/process-videos.js --force again
The whole thing runs through ffmpeg, which keeps surprising me with what it can do

The first video I published this way is the demo in my whimsical Pi extension note, showing the rotating status phrases while Pi works.

The best Pi web search extension?

2026-08-13T13:12:43Z

I run the Pi coding agent with pi-web-access installed, and recently I compared it against pi-web-agent, the other popular web search package for Pi. They solve the same problem in two different ways.

pi-web-access is a toolbox. It gives the model direct tools like web_search, source_check, and fetch_content, and the model chains them itself. But pi-web-agent is a bounded research workflow. It exposes one tool, web_explore, which plans queries, picks candidate pages, reads them, and synthesizes an answer with caveats, all internally.

	pi-web-access	pi-web-agent
Model interface	Direct tools, chained by the model	One `web_explore` call
Search providers	20+, including zero-config Exa MCP	6 backends, DuckDuckGo by default
Page reading	HTTP fetch plus readability extraction	HTTP plus headless Chromium rendering
Verification	`source_check` with passage citations	Built-in evidence quality and caveats
Special content	GitHub cloning, PDFs, YouTube, video	None
License	MIT	AGPL-3.0-only

For my setup, pi-web-access is the better default. It searches through Exa's MCP endpoint with no API key, while pi-web-agent's hosted backends need keys and otherwise fall back to scraping DuckDuckGo. pi-web-access also has source_check for verifying claims, plus GitHub, PDF, and video support that the other package does not have.

pi-web-agent wins in two places. It can render pages in headless Chromium, which handles bot checks and JavaScript-only sites that plain HTTP reads miss. And it is honest about weak evidence, reporting unreadable threads and narrow source sets as caveats instead of pretending. It also keeps transcripts much shorter in compact mode.

For everyday coding work, fetch this page, check this claim, search this API, pi-web-access covers more ground. For deep multi-source research where you want a disciplined workflow, pi-web-agent is the better fit.

People genuinely hate WebP images

2026-08-13T10:04:41Z

I have known for a long time that some of my friends don't like or rather don't understand the WebP image format, but I didn't know that people genuinely hate the format for some reason.

I use WebP images on this site and love them for how good they are – high quality at significantly smaller file sizes. In fact, WebP images also support alpha transparency just like PNGs, and are now supported by almost all web browsers out there.

Practically, I don't understand why people hate WebP images, but the following could be reasons when I think from others' perspective:

Unsupported by legacy apps and systems, and people had to convert them to other formats to use. Like you import it into a presentation or in a document, and it doesn't work.
Browsers and other major platforms suddenly started serving WebP versions of images, and it was kind of forced on them.

I think, people will keep hating the WebP format, always. And it will soon become outdated too, as there are better formats like AVIF and JPEG XL slowly taking over. These newer formats have better compression sizes, maintain sharper details, and even support full HDR color spaces.

Let's see.

By the way, I found this cool community website about JPEG XL that has a lot of comparisons and information about the format.

Whimsical working messages extension for Pi

2026-08-12T19:19:16Z

I use a small custom extension in the Pi coding agent that replaces the plain working status with playful phrases that keep changing while it thinks. It's based on Armin Ronacher's whimsical extension, which I customized with more colors, decorative symbols, and phrases that rotate every two seconds.

The phrase list has hundreds of entries, from short verbs to longer jokes and phrases:

Schlepping
Flibbertigibbeting
Negotiating with entropy
Herding cats in memory, etc.

Each update picks a random phrase and color, and it never shows the same phrase or color twice in a row. The status line resets as soon as Pi finishes the turn.

The extension lives at ~/.pi/agent/extensions/whimsical.ts and loads automatically on every startup. To try it, copy the code from this gist into your extensions folder and restart Pi. I also covered the extension in my pi agent setup post.

I like this setup and collection of words and phrases better than what Claude Code shows, because of better verbs and jokes, and cool colors as well.

Get $5 as the OpenCode referral reward

2026-08-23T00:00:00Z

Since OpenCode offers a referral reward, if you sign up to OpenCode by clicking on this link, you and I both get a reward of $5. It can be used to reduce your workspace's current usage.

For example, I signed up using someone's link and received the $5 reward that looks like this in my account:

I couldn't find any concrete explanation for this, but as far as I understand, if I'm about to hit my monthly limits, I can redeem the reward to reduce my limits by that value. Awesome, right?

Again, here's my OpenCode referral link

That's it.

Cheers!

Update:

As you can see in the screenshot above, applying one $5 referral reward in your OpenCode Go plan reduces the weekly usage significantly:

Limit Type	Usage reduction
5 hour limit	by 41%
Weekly limit	by 16%
Monthly limit	by 8%

Cool, right?

One thing worth knowing. The reward only lowers your Go plan's usage counters. If you don't renew Go, unapplied rewards show a disabled Subscribe to unlock button in the console, and applying one without an active plan fails. I couldn't find any expiry policy, so they likely stay on your account until you resubscribe.

And if you're really asking, the credit also can't be converted to Zen balance.

Grok 4.6 is here

2026-08-12T16:31:43Z

xAI just launched Grok 4.6, a little over a month after Grok 4.5. I loved Grok 4.5 because it was fast, reliable, and reasonably priced.

This time, as explained by xAI, the focus is on a few things:

Staying with complex tasks across many steps
Better self-testing and verification during longer tasks
Stronger first passes on visual and interactive projects

On xAI's benchmarks, Grok 4.6 High scores 61 on the Artificial Analysis Intelligence Index, exactly matching GPT-5.6 Sol Max and coming just behind Fable 5 Max at 62. Benchmarks are benchmarks, though, and I am more interested in seeing how it feels during real coding work.

I have used it a little inside Grok Build, and my first impression is that it feels a bit slower than Grok 4.5. It is still fast enough, and the overall quality is good, but the difference is noticeable. I have not used it enough yet to say whether the stronger reasoning and long-running agent capabilities make up for the slower responses.

The normal API pricing is unchanged, but cached input is now more expensive.

Price per 1M tokens	Grok 4.5	Grok 4.6
Input	$2	$2
Cached input, short context	$0.30	$0.50
Cached input, long context (≥200k)	$0.60	$1.00
Output	$6	$6

Grok 4.6 has a 500k context window, reasoning levels up to xhigh, and a fast variant that costs twice as much. It is available through the xAI API, Grok Build, and Cursor. I am still on the 3-month SuperGrok offer, so I tried it in Grok Build.

Apart from this, xAI is offering 2x the usual included usage in Grok Build and Cursor for the first week.

I also discovered this write-up from Eric at Cursor, and it has some really good suggestions about using Grok 4.6. He has been using it as his daily driver for a few weeks. Here are the tips that stood out.

skip phrases like "work very hard", they barely change the outcome
a short prompt plus a clear preference is usually enough, because the model's taste is good
write a long spec only when you already know exactly what you want
say what done means, instead of telling it to keep going
ask it to open the app, click through real user paths, and fix what it finds
for visual work, tell it to capture a screenshot, list what is wrong, then fix only those things
do not trust a summary that says it is finished, run it and look

The verification one is the highest leverage. He tried a two-page spreadsheet spec and a three-sentence prompt, and both apps came back almost the same. Adding that one "use it and check" sentence is what actually changed the result.

Honestly, I'm pretty excited about xAI and Grok. I think, it has a lot of potential to win the AI race. I found this post on X that I completely agree with.

If you think, only a few months ago xAI's Grok wasn't used by anyone, at least for coding. But now, everyone is talking about it.

I'm hopeful, but let's see.

Claude will watermark AI-generated content

2026-08-12T00:00:00Z

Anthropic says supported Claude models will add imperceptible watermarks to generated text. The watermark is part of the text itself, so it can travel with copied text and can even survive some editing.

For supported images and other files, Claude will attach signed C2PA provenance metadata instead. Anthropic says detection tools and technical details are still to come, and these marks are signals rather than perfect proof of origin.

I am not sure how this works, but I think it might work based on this paper. And this is similar to Google's SynthID that also embeds imperceptible watermarks in AI-generated content.

Update: Aug 12, 2026

Just saw an update on this as Thariq from Anthropic confirmed that the watermark detection API will be free to use.

I predict lots of big publishing platforms like Substack, Medium, and even search engines like Google and others will use the Claude API internally to decide what content to give more priority. And in the future, I guess, more AI providers will launch such an API.

Pi agent is just better

2026-08-10T16:26:56Z

Composio ran DeepSeek V4 Flash through 8 agent harnesses on 30 agentic tasks, and as per the report Pi agent came out on top in almost every metric. Here is the leaderboard for tasks passed.

Pi agent passed 20 of 30 tasks, 3 more than the next best harness (Oh My Pi at 17). Claude Code, Codex, and Deep Agents tied at 16, and the rest were at 14-15.

Cost per successful task is where Pi pulls ahead the most. It came in at $0.028, the cheapest of all 8 harnesses, while Claude Code at the other end cost $0.195, almost 7x more. Pi's median time per task was 132 seconds, only Claude Code and OpenCode were slightly faster.

The same model delivered 47-67% task success, cost $0.019-$0.104 per task, and took 122-272 seconds median time, depending on the harness. Their closing point is a good one. Benchmark the model-harness pair you will actually use, not the model in isolation.

Nice to see Pi win a third party eval like this, since I run Pi with DeepSeek as my default setup anyway.

Kapture Fast – one-click screenshot to clipboard

2026-08-10T03:22:51Z

I built a tiny Chrome extension called Kapture Fast that captures the visible part of a tab and copies it to the clipboard in one click. Just click the toolbar icon or right-click the page and pick "Copy screenshot to clipboard".

It only captures the visible viewport, not the full page. A checkmark flashes on the icon when it works, and on failure a ! badge shows the reason on hover.

It needs just four permissions, no network requests, no analytics, and the screenshot never leaves the machine. Open source under MIT, load it unpacked from the repo in about a minute.

This is another Chrome extension I've shipped after the Minimal X cleanup extension, and I've been using it daily.

Once the screenshot is in the clipboard, I paste it on socials, drop it into chats while vibe coding, or save it on macOS when I need it as a file.

Cursor Pro and SuperGrok usage comparison

2026-08-10T02:20:47Z

I had this question: which subscription is more value for money when using the Grok 4.5 model – Cursor Pro ($20/mo) or SuperGrok ($30/mo). And I just came across this post on X that does a comparison between the two.

Here, I have created a comparison table to better understand the usage these subscriptions get you.

Subscription	Price	Tokens per month	Tokens per $	Value advantage
Cursor Pro	$20/mo	716,077,180	35,803,859	Better value
SuperGrok	$30/mo	987,902,940	32,930,098	–

Basically, if you consider the $10 price difference between the two, Cursor gets you ~8.73% more tokens than SuperGrok.

tl;dr – Cursor Pro is better than Grok.

I have used Cursor previously, and I am currently using SuperGrok, but since I availed their promotional offer of $30 for 3 months (i.e., $10/mo), SuperGrok is better value for money for me right now.

How 'keep reading' picks related posts now

2026-08-09T17:36:38Z

The "keep reading" block under every post and note used to pick its suggestions by counting shared tags. Most matches won.

That sounds reasonable until you look at my tags. The ai tag alone sits on 186 of my 637 posts and notes, so sharing it counted for as much as sharing something rare like hetzner. Hundreds of candidates tied for one shared tag. The tiebreakers collapsed, and the sort quietly turned into "show the newest thing tagged ai".

Three things stood out when I finally measured it.

289 entries had never shown up as a suggestion anywhere on the site
one note about my terminal config was sitting on 113 pages
most entries were getting three suggestions instead of five

So now it scores every pair of entries instead of sorting them, and four things feed that score.

shared tags, weighted so rare ones count for more than common ones
how similar the titles and descriptions are
internal links, counted both ways, so linking A to B also points B back at A
recency, but only enough to break ties

The title matching did most of the heavy lifting here. Around 40% of my entries carry a single tag, so tags were never going to say much about them, but titles always do. The internal links I add by hand turned out to be the most trustworthy signal of the lot.

Where it landed.

every entry now gets a full five suggestions
entries that never surfaced dropped from 289 to 36
nothing appears on more than 20 pages anymore

I can also pin suggestions from the frontmatter now, where scoring fills whatever slots are left.

related:
- /blog/some-post/
- /raw/some-note/

It all runs once at build time instead of per page, so the build did not get any slower. I had reorganized this block once before, and this time it is the matching underneath that got fixed.

Just learned that Ahrefs DR API is free

2026-08-09T15:00:04Z

I just got to know that Ahrefs has a free API that returns DR (Domain Rating) for domains, and it's completely free to use. You do require a free API key and requests do not consume any API units.

I tested it for deepakness.com with a free API key, and DR comes out to be 46, as you see in the response below.

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.ahrefs.com/v3/public/domain-rating-free?target=deepakness.com&output=json"

Actual response:

{
  "domain_rating": {
    "domain_rating": 46.0,
    "license": "http://ahrefs.com/legal/domain-rating-license"
  }
}

Unauthenticated calls still work today but return a deprecation warning as they now return 401 unless you send the free key. If you use the data, Ahrefs requires attribution as "Domain Rating by Ahrefs" with a link to ahrefs.com, under their Domain Rating License program.

I liked this because this can be used for analyzing domains in bulk and then there can be other interesting uses as well.

Pi agent supports Mermaid diagrams now

2026-08-07T14:11:46Z

From the new v0.84.0 update, the Pi coding agent has now started supporting Mermaid diagrams natively. The agent can now show a preview of the diagram directly inside the terminal you're using, as you see below.

It's turned on by default when you update to the new 0.84.0 version by running the pi update --all command. It's set to streaming as you see below, but you can turn it off or change it to final as well, and you can learn about it more from the docs.

I think, this is a nice addition to the agent as it helps users visualize complex ideas in a better way. If you see the first diagram above, that is basically the entire architecture of deepakness.com.

Apart from this, I loved the new fullscreen TUI mode that you can turn on from the settings. It keeps the text-box pinned at the bottom when you scroll. It's very useful.

Removing webmentions from this site

2026-08-07T04:20:55Z

I removed webmentions from this site entirely today.

How the setup worked (receiving via webmention.io + Bridgy, sending via webmention.app, Eleventy fetch at build time, UI under posts) is already written up in an earlier post.

I removed them because they were not adding much value, and the UI below posts felt messy. Email and Mastodon CTAs already cover how to reply, and the webmention block mostly cluttered the bottom of posts without making the site better to use.

What still shows under posts and notes is Comment via Email, and Comment on Mastodon when a post has a status URL.

By the way, I am not against the webmention protocol. But it's a clean slate for now; the implementation post is enough if I ever rebuild it.

Parakeet Unified EN 0.6B model in Handy is great

2026-08-06T00:00:00Z

Recently, a new model called Parakeet Unified EN 0.6B appeared in the Handy app. When I wrote about finding the best local speech-to-text app, I was using Parakeet v3, which was already great. But this new Unified EN 0.6B model is on another level.

It is significantly faster and much more accurate than the earlier models. The latency drop is immediately noticeable, and words appear almost instantly as you speak, with virtually zero delay. I am running it on an M2 MacBook Air with 16 GB RAM, and it works flawlessly without slowing down the system.

Punctuation, capitalization, and technical terms are also handled much better.