Raw notes

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.

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?

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.

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.

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.

After trying the Kero terminal for a few days, I came back to cmux and audited how it handles configurations and themes so I can quickly restore everything if I ever reinstall or move to a new Mac.

Because cmux uses Ghostty as its underlying terminal rendering engine, terminal styling is separate from cmux app settings, and here's how it looks on my computer.

1. Terminal visual theme & fonts live inside the Ghostty config file:

~/Library/Application Support/com.mitchellh.ghostty/config.ghostty

This is also symlinked to ~/.config/ghostty/config. It uses the built-in GitHub Dark Default theme, Fira Code ligatures (+calt, +zero, +ss01), font thickening, a 50,000-line scrollback buffer, and clipboard auto-copy on select.

2. cmux app settings & shortcuts live in the main cmux config file:

~/.config/cmux/cmux.json

This configures preferredEditor: "code", commandPaletteSearchesAllSurfaces: true, matching sidebar background blending (matchTerminalBackground: true), minimal mode, pane split shortcuts (cmd + d), sidebar toggle (cmd + b), and agent notification hooks.

3. Active workspaces & open tabs live in the session state file:

~/Library/Application Support/cmux/session-com.cmuxterm.app.json

Here is the exact config.ghostty content for the terminal theme and font:

# Theme (GitHub Dark Default, built into Ghostty)
theme = GitHub Dark Default

font-family = "Fira Code"
font-size = 14
font-feature = +calt
font-feature = +zero
font-feature = +ss01
font-thicken = true

# Scrollback
scrollback-limit = 50000

# Window
window-padding-x = 20
window-padding-y = 12
window-padding-balance = true
window-inherit-working-directory = true

# Cursor
cursor-style = bar
cursor-style-blink = false

# Mouse & Clipboard
mouse-hide-while-typing = true
copy-on-select = clipboard

For quick CLI interaction, I added these productivity aliases to ~/.zshrc:

alias cm-diff="cmux diff --source unstaged"
alias cm-diff-staged="cmux diff --source staged"
alias cm-md="cmux markdown"
alias cm-browser="cmux browser open"
alias cm-jump="cmux jump-to-unread"
alias cm-status="cmux list-status"

Also, cmux automatically creates timestamped backups of cmux.json inside ~/.config/cmux/ whenever settings are saved (like cmux.json.bak.20260722T055253).

If I ever reinstall cmux or move to a new Mac, I just need to recreate the folders and restore those files:

mkdir -p ~/.config/cmux ~/.config/ghostty ~/Library/Application\ Support/com.mitchellh.ghostty
ln -sf "~/Library/Application Support/com.mitchellh.ghostty/config.ghostty" ~/.config/ghostty/config

Because these files sit in standard macOS user directories rather than inside the .app bundle, simply uninstalling cmux.app leaves all themes, sessions, and shortcuts completely safe and intact.

If you use the Antigravity CLI via agy, you might notice an "AI: Out of credits" warning in the status bar footer.

Toggling "Use AI Credits" off via /config inside the CLI fixes it temporarily, but every time you exit and reopen agy, it automatically turns back on and the error message shows up again.

This happens because changing the setting in the CLI UI only updates the active session, while the persistent global config file keeps "useAiCredits": true.

To turn it off permanently:

1. Open ~/.gemini/config/config.json in your text editor.
2. Locate "useAiCredits" under userSettings and change it to false, something like this:

{
  "userSettings": {
    "useAiCredits": false
  }
}

3. (Optional) You can also open ~/.gemini/antigravity-cli/settings.json and add "useAiCredits": false there.

Save the file and restart agy and the warning won't appear in the footer anymore.

On and off, I have been using Claude Code for several months, and in all that time I never ran any model below Extra High effort. It always felt like if I used a lower effort, the model would mess up my existing code. Even when Opus 5 launched, I kept it at Max without thinking twice.

For the last few days, I've been running Opus 5 at Low instead, and I'm loving it so far. It's faster, and it consumes noticeably fewer tokens. I'm working on a huge project right now, so not running out of limits halfway through the day matters a lot more to me than squeezing out the last bit of reasoning.

Claude Code is the tool I use almost entirely for frontend and design work, and that's where this holds up best. For UI design work, the difference between the higher efforts and Low is negligible – I can't really tell which one wrote the component. Higher effort now feels like overkill for most of what I do day to day.

So my default has flipped. I start at Low and only bump the effort to Medium or High, and almost never to Extra High or Max, when a task actually asks for it, like a tricky bug or a change spanning a lot of files.

SharePDF has now crossed 400 users and tens of new users are signing up every week. The rate varies from week to week, but it's growing consistently.

The MRR is currently at $37.33 and I am very happy with the progress.

I previously wrote about how I publish blog posts and notes so fast, where I mentioned using simple terminal scripts and background automations to remove friction. One part of that workflow was an n8n automation connecting RSS feeds to Typefully to automatically draft new posts to social media.

While n8n worked, it relied on polling RSS feeds after Netlify finished deploying, and didn't give me fine-grained control over which social platforms a specific post should go to.

So I replaced the n8n setup with a small Node.js script scripts/sync-typefully.js built directly into my existing pnpm blog:push and pnpm raw:push workflow commands.

Here's how it works:

1. Whenever I publish a post, git commits and pushes the code to GitHub first.
2. The script polls the live post URL on deepakness.com until Netlify returns a 200 OK status. This ensures no broken 404 links on social media.
3. Mastodon and Bluesky are enabled by default so I don't have to specify them.
4. If I want to send the draft to extra channels like Threads, X, or LinkedIn, I can pass a flag like pnpm raw:push --platforms=threads,x.
5. Once live, it calls the Typefully API to schedule the draft for the next free slot.

And the output in the terminal is shown like this:

[Typefully Sync] Found target file: content/raw/typefully-local-sync/index.md
[Typefully Sync] Configured platforms: mastodon, bluesky
[Typefully Sync] Waiting for Netlify deploy... Polling https://deepakness.com/raw/typefully-local-sync/
[Typefully Sync] ✓ Live page confirmed! (HTTP 200 OK after 42s)
[Typefully Sync] Sending draft to Typefully API...
[Typefully Sync] 🎉 Draft successfully scheduled in Typefully!
  Draft ID: 10183778
  Draft Title: "Replacing n8n with a local script for Typefully drafts"
  Platforms: mastodon, bluesky
  Schedule: next-free-slot

Now there are no external n8n workflows to maintain, zero broken link issues, and full control over social distribution directly from the terminal.

Absolutely love it.

Update: August 05, 2026

I updated scripts/sync-typefully.js to automatically schedule drafts for 15 minutes in the future by default (calculated right after Netlify deployment finishes), instead of pushing to next-free-slot.

I can also customize the delay directly from the command line using the --in flag:

• pnpm raw:push --in=5 – Schedules 5 minutes from now.
• pnpm blog:push --in 20 – Schedules 20 minutes from now.
• pnpm raw:push --now – Publishes immediately.
• pnpm raw:push --next-free-slot – Keeps the queue slot behavior.

I just discovered this new terminal app called kero.sh that basically removes the need to open an IDE like VS Code or so when vibe coding. It was recommended to me on X, and I tried and liked it immediately.

I mainly use the cmux app that works great, but the inbuilt files and git extension in Kero caught my attention. I miss a few things in the Kero terminal though, like the ability to drag terminal tabs to the left, right, bottom, or top sides as possible in cmux. But I can still use cmd + t or cmd + d in Kero and that is enough.

Another thing I didn't like about Kero is, cmd + + or - didn't work for zoom in or out, as I can do in basically any other terminal. You can only adjust the font size from settings, if you want bigger or smaller text.

Currently, I'm mainly using cmux but testing and trying Kero with my workflow as well. And if I like it after a few days, I'll migrate everything to using Kero.

Let's see.

Update:

Another major thing I didn't like about Kero is that it doesn't persist AI agent sessions (like Pi agent or OMP agent) when the app is restarted. In cmux, if I'm working with Pi or OMP agent and close and reopen the app, all those sessions automatically stay open and I can just continue typing new prompts right away. That doesn't happen in Kero.

So after using it for 3-4 days, I'm back to using cmux.