Raw notes

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.

By the way, for all of this I took help from OpenCode as it was easy to install and use in terminal, and it worked great. It researched the problems and told me what to do.

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.

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.

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.

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.

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 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.

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.

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.

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.

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.

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.

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.

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

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

3. 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.

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.

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:

1. 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.
2. 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.

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.

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.

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.

1. skip phrases like "work very hard", they barely change the outcome
2. a short prompt plus a clear preference is usually enough, because the model's taste is good
3. write a long spec only when you already know exactly what you want
4. say what done means, instead of telling it to keep going
5. ask it to open the app, click through real user paths, and fix what it finds
6. for visual work, tell it to capture a screenshot, list what is wrong, then fix only those things
7. 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.

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.

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.

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.

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.

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.

1. shared tags, weighted so rare ones count for more than common ones
2. how similar the titles and descriptions are
3. internal links, counted both ways, so linking A to B also points B back at A
4. 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.

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.

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.