DeepakNess - Everything

Added a paper theme and some other updates

2026-07-20T01:22:07Z

A few months ago I added dark mode to this site, and yesterday I spent some more time polishing the themes and a few other small things around the site.

There is now a third option called paper – a warm cream look that feels nicer for longer reading. Links stay monochrome in this mode, so the page feels quieter overall. The theme button in the header now cycles between light, paper, and dark. Paper uses a coffee icon, which somehow felt right for that cozy reading vibe. If you haven't picked a theme yet, the site still follows your browser preference, and once you choose one it remembers it.

I also made dark mode a bit more readable – lifted the palette a little, cleaned up muted text, and made code blocks look consistent across all themes instead of shifting around. A few small alignment issues with chips and comment actions are fixed too, so switching themes shouldn't nudge the layout anymore.

Apart from themes, I updated my profile photo in the header. It's an opaque square photo now, and clicking it opens a larger floating preview. But clicking on the name "DeepakNess" still takes you to the home page – only the photo opens the preview, as you see above.

Also upgraded a bunch of dependencies and switched the project over to pnpm while I was at it, but that's just under the hood.

You can visit the colophon page to see more technical details of the website.

That's the update.

SharePDF reaches 350+ users

2026-07-19T15:27:30Z

SharePDF recently hit the 350 users mark, and it makes me so happy about it. This is a kind of my first ever SaaS that I built from scratch with Bikash, and seeing this grow this much fills my heart with joy.

Apart from this, we also completely revamped the UI and UX for SharePDF recently and now all pages follow a different design aesthetic everywhere.

That's it.

That's the update.

Scraping using Pi agent + Cursor SDK + Codex /goal

2026-07-19T04:17:16Z

I think, I have found the perfect web scraping setup for myself. Currently, I am using the Cursor SDK via pi-cursor-sdk and Codex's /goal via pi-codex-goal inside the Pi agent using Cursor's Composer 2.5 model and doing great so far.

As you can see in the above screenshot, the scraper is running for over 2 days, continuously. It stopped a few times due to the model downtime but then /goal resume continued right from where it stopped.

Basically, I am using the Composer 2.5 model from Cursor for this. The model writes the scraping script in Python and then keeps the process running, if it fails for any reason, the model makes necessary changes in the script and keep it running. For the last few days, as you see in the screenshot below, you can see the sudden spike in my usage. I have used more than 1.5 billion tokens as I'm running multiple scrapers at the same time, continuously.

I'm on the Pro+ plan ($60/mo) on Cursor and I think it's the best value for money AI subscription right now.

macOS 27 Beta dasd eating 40+GB of RAM

2026-07-16T12:04:47Z

I installed the macOS 27 Golden Gate developer beta from the very start, and now running into this dasd process consuming too much computer resources most of the time. I thought this will be solved eventually, but it hasn't been solved in the developer beta 3 or even in the first public beta.

Earlier, I wasn't having this issue (but most people are having this from the start) and started having this only after installing the latest update. My MacBook M2 Air 16 GB is now consuming 40+GB of RAM+Swap memory, and computer starts running very slow.

So... I researched and found this Reddit post where a person shares a solution that many people replied that it worked for them. I also tried the following command, and surprisingly I'm not running into the issue again.

sudo rm -rf /private/var/db/powerlog 
sudo reboot

You need your admin password to run this, and it didn't break anything else for me, so it's safe to run.

Honestly, I don't know what it does, but you can look it up.

Hope this helps.

Got a monitor stand for my desk

2026-07-12T06:57:14Z

Earlier, I used to keep my monitor towards the right of my laptop, as you see in the old work setup. But a friend suggested keeping the monitor behind my laptop at some height, and I just got a monitor stand for my desk, as you see below.

Honestly, it does make my work setup a bit better. I actually feel comfortable working like this because now I don't have to turn my head towards the right side to look at the monitor.

And here's what my current setup looks like now:

The wires and all are still a bit messy, but I'm perfectly okay with that. In fact, I love seeing a bit of wires going here and there on the side.

Minimal X v2.4 is here

2026-07-12T04:14:09Z

Just released a new version of the Chrome extension Minimal X that lets you remove the persistent highlighted section from the /explore page.

For example, currently this football section is highlighted and as I don't watch football, it's not useful for me and kind of distracting. So... when you turn on this new option "Start Explore at Today's News" then the highlighted section is removed and the page starts from the usual Today's News section.

I will keep adding more features to make X experience even better.

Using Composer 2.5 as the Worker inside Cursor

2026-07-10T11:28:19Z

Earlier I shared my experience about using the new Grok 4.5 model and also about my orchestrator + worker setup inside Cursor. I was using either GPT-5.5 or Opus 4.8 or even Fable 5 models as orchestrators, but my preferences have recently changed.

Nowadays, I'm mostly using Grok 4.5 as the orchestrator and sometimes even GPT-5.5 Terra. These models are pretty good at orchestrating bigger, complex tasks. I just add this below line in my prompts in Cursor, and it works flawlessly.

Delegate heavy works to the Composer 2.5 model.

In fact, this trick is working pretty well inside Claude Code as well. I use Fable 5 as the orchestrator and then include the below line in my prompt that hints the agent to use Sonnet 5 as the worker.

Delegate heavy works to the Sonnet 5 model.

Since Sonnet 5 is fast, the work is finished faster and often pretty low on the limits as well.

Grok 4.5 first impressions

2026-07-08T19:46:22Z

Cursor partnered with SpaceXAI to train Grok 4.5 and the model is now live. I just tried it inside Cursor and here are my first impressions:

It's not as good as Opus/Fable models when it comes to frontend design related tasks. I asked it to create a few webpages, and the UI is decent but not very good. I will compare its UI design capabilities with GPT-5.5, which is not very good.

Grok 4.5 is very fast when compared to the latest Opus or GPT models, even without the fast mode turned out. Also, it's reasonably priced at input $2 per million tokens and output at $6 per million tokens. As of now, I used around 13 million Grok 4.5 tokens inside Cursor, and it has costed me 2.6% of the monthly usage, as you see.

As you see above, Grok 4.3 billed inside Cursor as API pricing, but the new Grok 4.5 comes in the Auto + Composer pool.

Grok 4.5 has currently 2x limits inside Cursor for a week, and is completely free inside Grok Build if you have a paid plan for SuperGrok or X, as announced by the xAI team in this post.

Apart from this, the new model is 1.5T mixture of experts model, trained from scratch.

From my limited use, the model feels much better than Composer 2.5, and it feels like I am using GPT-5.5 inside Codex. It's fast and pretty good with non-frontend related tasks.

They mention in the blog post that:

Grok 4.5 and Composer 2.5 are two different model weight classes, and we're excited to support both sizes and weights. Composer 2.5 will remain offered, and we will release new models of this size going forward.

Loved this pricing comparison of Grok 4.5 with other popular models:

Update: Jul 9, 2026

The more I use Grok 4.5 the more I love it, and using it inside Cursor makes me feel I am using GPT-5.5 inside Codex. It's flawless and very reliable as well.

I think, if you consider the pricing Grok 4.5 is currently the best AI model out there.

Cloudflare introduces Workers Cache

2026-07-07T10:35:02Z

Cloudflare just introduced Workers Cache which, basically, returns cached HTTP responses from the Worker without executing the Worker code first. And it's going to significantly lower down the running costs, at least for me.

I found a great demo on X, about how it works.

I'm still learning about it and will soon implement to all my projects hosted on Cloudflare Workers. There must be more than 10 small-big projects hosted on Workers, and this is going to be a great weekend.

Updated to the macOS 27 Developer Beta 3

2026-07-07T04:37:32Z

I just updated my MacBook M2 Air to the latest macOS 27 Golden Gate Developer Beta 3 and loving it so far. Love the wallpaper and everything else.

For some reason, I like macOS 27 Golden Gate more than the previous macOS 26 Tahoe. Even though 27 is in developer beta, it's still very good and feels better to use.

Cursor orchestrator and worker setup

2026-07-03T02:03:00Z

After this post from Eric, I wanted a simple Cursor setup where a strong model plans and delegates, and a cheaper worker does the actual edits. The pattern: pick your orchestrator in the model picker, add custom subagents pinned to composer-2.5[fast=false], and attach a manual rule only when you want delegation.

Although, I am not using the Fable model, but it still works pretty well. First, I tried the GPT-5.5-Medium model as the orchestrator, but later I shifted using the Opus-4.8-High as it seemed a bit better and cheaper in Cursor.

Here's the folder structure:

.cursor/
├── agents/
│   ├── implementer.md
│   ├── auditor.md
│   └── verifier.md
└── rules/
    └── orchestrator-worker.mdc

First, I created this file .cursor/rules/orchestrator-worker.mdc with the following contents:

---
description: Strong model orchestrates; Composer 2.5 standard subagents do scoped work. Apply manually with @orchestrator-worker.
---

# Orchestrator / worker mode

Activate only when this rule is attached.

## Models

- **Orchestrator (parent):** your strong model in the picker (e.g. `claude-opus-4-8-thinking-high`)
- **Workers:** `composer-2.5[fast=false]` – pinned in `.cursor/agents/`

## Parent

Plan, decompose, delegate, and review. Give each worker one concern, enough context, a definition of done, and a short report. Run independent pieces in parallel. Review before merging. Keep work on the parent when judgment is the whole job.

Do not spawn built-in `explore` or `generalPurpose` subagents – they default to Composer Fast.

## Workers

| Subagent      | Use for                                    |
| ------------- | ------------------------------------------ |
| `implementer` | Code edits, refactors, tests, file changes |
| `auditor`     | Read-only audits and exploration           |
| `verifier`    | Post-implementation review                 |

Then created the implementer subagent .cursor/agents/implementer.md with the following contents:

---
name: implementer
description: Implementation specialist. Use for code edits, refactors, tests, and file changes once a plan exists.
model: composer-2.5[fast=false]
---

You are the implementation worker.

- Execute the parent's plan: edit files, run targeted tests, fix failures.
- Follow existing project conventions before adding new patterns.
- Return a concise summary: what changed, tests run, blockers.
- Prefer the smallest correct diff. Do not replan unless blocked.
- Do not create git commits unless the parent asks.

Then the auditor subagent .cursor/agents/auditor.md with read-only access:

---
name: auditor
description: Read-only auditor. Use for audits, exploration, and reviews instead of built-in explore.
model: composer-2.5[fast=false]
readonly: true
---

You are a read-only audit subagent.

- Explore assigned domains thoroughly. Never edit files.
- Report severity, location, finding, and recommendation for each issue.
- End with a brief domain summary.

Lastly, the verifier subagent .cursor/agents/verifier.md, again with read-only access:

---
name: verifier
description: Read-only reviewer. Use after implementation to check work matches the plan.
model: composer-2.5[fast=false]
readonly: true
---

You are a read-only verification subagent.

- Compare implementation against the parent's plan or acceptance criteria.
- Check tests cover the change when applicable.
- Return verdict (pass / pass with notes / fail) and gaps. Do not edit files.

Because model: composer-2.5 alone was still resolving to Fast-mode, I have used composer-2.5[fast=false] explicitly as the model string, as you see above.

I only use this orchestrator-worker setup when needed, and not all the time. Here's how I do it:

New Agent chat → pick the orchestrator model in the model picker
Type @orchestrator-worker and my task
Parent plans → implementer codes → optional verifier reviews

I prompt something like this:

@orchestrator-worker Refactor the auth module.

And for normal single-agent work, I would skip @orchestrator-worker and use any model directly (mostly Composer 2.5 itself).

Lastly, if you're using this you can also add your project-specific details anywhere it helps:

orchestrator-worker.mdc – your orchestrator model slug, stack-specific delegation rules
Subagent files – test commands, commit rules, security checks, framework conventions
AGENTS.md (optional, repo root) – build commands, folder layout, code style; stays on without forcing orchestration

The rule is manual-only, so it doesn't affect every chat.

If you're setting this up, just give the link to this post to your Cursor agent and ask it to set everything up for your project. And you can also visit Cursor' docs about subagents for more info on how to set everything up in a better way.

Does AI makes you less productive?

2026-07-01T01:50:33Z

Came across this post from Dominik Sobe on X, and liked how he explains that he gets to do more with AI but still feels less accomplished. I am going to copy the post content here:

AI lowkey fu**ed up my productivity in a way I didn’t expect and I’m not sure how to feel about it.

On any given day:

I code more than ever.

I ship features faster than ever.

I do more marketing than ever before.

I even make slightly more money than before.

Yet, I feel like I have achieved nothing at the end of the day.

I go to bed lots of times lately feeling unaccomplished.

There’s this lingering thought of I could’ve done more.

Run more agents in parallel, run them while I’m eating, while being in the gym, heck they should do work while I sleep! You get the gist.

It sometimes drives me nuts lol

I remember days pre AI where I’d work on a feature for an entire week (that now takes me less than a day) and still go to bed feeling great and happy.

Now, there’s seemingly never enough.

What do I do to fix this? Anyone else having similar feelings?

I like this post a lot.

Found this The Aptness of Anger paper

2026-06-30T07:51:17Z

YouTube recommended me this video, and then I discovered Amia Srinivasan's paper titled The Aptness of Anger and liked its abstract (copied below) so much that I decided to read it whole.

While the paper is about a simple topic, it's still an interesting read (I'm halfway through it). The main point of the paper is that getting angry about unfairness is a valid and correct response, even if the anger does not help solve the problem. Basically, the author argues that we should not only judge anger by whether it is "useful" but we should also respect anger when it is the truthful emotional response to an unjust world.

If you love the topic, you'll love reading it.

Using Cursor Pro+ plan this time

2026-06-28T00:08:27Z

Last month, I subscribed to Cursor's Pro plan for $20 a month and absolutely loved using the Composer 2.5 model. I used more than 700 million tokens on the plan with a mix of Auto, Composer 2.5, Composer 2.5 Fast, Opus 4.8, and GPT-5.5 models.

So... this month I decided to get the Cursor's Pro+ plan for $60 a month, and it's been great so far. In just a day, I have used more than 175 million tokens across Composer 2.5 standard and fast models, as you see in the screenshot here.

Currently, I am also subscribed to Claude $100 plan that I use mostly for frontend design and then use Composer 2.5 for everything else. I was also subscribed to Codex $100 plan, but the subscription ended a week ago, and I think I am good with the current setup (until next month, of course).

By the way, I track how I am currently using AI on this regularly updated page that you might find useful.

Coming back to the current setup, Composer 2.5 has been pretty good. I don't give it very large prompts but ask it to make small changes, and it's been great so far. This saathi.fyi project that I am working on with Amit, is almost entirely built by Cursor after the initial frontend design by Claude.

Launching Minimal X 2.0

2026-06-24T03:41:36Z

I use X.com fairly often, but the interface keeps getting noisier – promoted posts, engagement counts, Grok buttons, the trends sidebar, chat drawers, and whatnot. I had already built Minimal X a while ago to hide some of that clutter, but v1 was pretty basic. It just ran always-on with no settings.

So I rebuilt it as v2.0. Now there's a popup with toggles for every cleanup option, sensible defaults, and you can turn individual things on or off. By default it hides promoted posts, share buttons, Grok actions, Grok/Chat drawers, the right rail, and uses a compact icon-only left sidebar. You can also optionally hide engagement counts, the home composer, the new-post pill, and extra nav items like Grok, Premium, Creator Studio, and Articles.

Some of the things v2 can do:

Hide promoted timeline posts and Explore promotions
Hide share buttons and Grok action buttons on posts
Hide the right rail, including trends, verified orgs, and footer clutter
Use a compact icon-only sidebar (notification badges still work)
Optionally hide reply, repost, like, bookmark, and view counts

It's lightweight, runs only on x.com, and doesn't collect any data. Settings are saved with Chrome sync.

I've been using it daily for the last few days and the calmer timeline is honestly hard to go back from. If you try it, let me know what you think.

I Bought a $100 Laptop – Mid 2014 MacBook Pro

2026-06-21T00:49:52Z

Two days ago, I was at home and ordered food online. I went to pre-approve the delivery on the apartment's app, and saw an ad selling an old MacBook Pro (Retina, 15-inch, Mid 2014, 16 GB RAM, 120 GB SSD) for only ₹12,000 (~$130) from another resident. I inquired immediately and went there to take a look at it.

The laptop seemed in good condition, I used it for a bit, checked random stuff, and then was ready to buy. I was ready to pay the listed price, but then just asked if they could lower the price to ₹9,000 (~$100) and they agreed immediately. I, then, paid the price and took this 12-year-old laptop home, with its original charger.

When I asked, their main reason for selling was that they weren't able to install newer apps – the laptop was still running macOS Big Sur, the last official update from Apple. For me, before my current MacBook Air M2, I had never used any Apple product, so I was just curious about this decade-old laptop.

By the way, this is how the laptop looks. I absolutely love the backlit Apple logo here.

After getting the laptop, I researched a bit about it and used the OpenCore Legacy Patcher (OCLP) and upgraded to macOS Ventura 13.7.8 and it's running fine so far. I tried installing the Codex app and a few other apps on it and they all work as expected, no lag or slowness at all. Obviously, it's not as powerful as my M2 Air, but it's more than worth the price I paid.

I haven't spent much time on it yet, but it seems like a good machine. It's heavy, but I can keep it open on my desk and use it for scraping or some long-running tasks, so I don't have to keep my main laptop running (Codex /goal, I'm looking at you).

I even tried installing Omarchy Linux on an external SSD connected to the laptop, and it works fine as expected. Here's a picture of it booted into the Omarchy OS.

The speakers aren't great, but that's not an issue because that's not what I got it for.

For now, I will keep exploring things I can do with this second laptop.

Let's see how it goes.

Best web scraping workflow using Codex

2026-06-18T03:11:09Z

I needed to scrape 10s of thousands of rows of data from a website with strict rate-limits and all. Earlier, I would have used a tool like Octoparse for this, but this time I asked OpenAI's Codex to do it.

I asked the agent to scrape the website with required data points by sending it a very simple 1 line prompt:

scrape all pages from XYZ website with all important data points, start this as a /goal and don't stop until all required and important information is scraped.

And Codex started the process as goal that ran for more than 13 hours 46 minutes and used only 757k tokens. Because AI itself wasn't scraping the website, but Codex generated and executed the scraper, monitored failures, patched the code, handled 404/410 cases, adjusted for rate limits, added fallback logic, exported the dataset, and ran strict validation.

write code → run it → inspect errors → patch code → resume → validate → repeat

Next time, if I have to refresh the scraped data from the website, I just have to run python scraper.py and it will run without errors as Codex has perfected the script now.

Cool, right?

Access Telegram without VPN from India

2026-06-17T06:40:11Z

The Indian government has banned Telegram in India for a limited time and the ban is implemented to prevent organized cheating rackets and misinformation ahead of the NEET-UG re-examination. I don't think this is a sensible solution, because my work is affected as I did all my work related communication in Telegram.

While I have now fully moved to Signal, here's a trick to still use Telegram in India without using VPN but using the Cloudflare 1.1.1.1 DNS resolver. I tried this both on my macOS laptop and also on my Android device, and it works as expected.

On my macOS device:

I downloaded the macOS app for my device and installed it and just connected as Traffic and DNS (UDP) as you see in the screenshot here.

After that I opened the Telegram app, and it got connected and started working after a few seconds.

On my Android device:

I already had the 1.1.1.1 app installed on my Android device, but that's not available on Google Play Store anymore. However, there's a very simple way to do a manual setup on Android in their official docs that you can follow.

After the setup, just open the Telegram app, and it works as expected.

Hope this helps.

No Thanks, ChatGPT 3.0.0 is here

2026-06-11T10:22:21Z

I just released v3.0.0 of No Thanks, ChatGPT, my small Chrome extension that removes annoying popups and interruptions on ChatGPT.

Earlier, it mostly did one thing: keep ChatGPT quieter when browsing while logged out. It dismissed things like the "Thanks for trying ChatGPT" dialog, signup prompts, cookie banners, sidebar upsells, and similar interruptions.

But now it does one more useful thing.

You can export ChatGPT conversations locally.

The new version adds a small export button inside ChatGPT, and the extension popup also has the same export options. You can export the currently loaded conversation as:

Markdown
JSON
HTML
TXT

It keeps clear User and Assistant turns, and tries to preserve common formatting like headings, lists, links, tables, and code blocks.

I wanted to keep this privacy-friendly, so the export happens locally in the browser. There is no backend, no analytics, no storage permission, no downloads permission, and no external network request. It just reads the conversation already rendered on the page when you click Copy or Export.

I also updated the extension icon because it is now more than just a "no thanks" popup blocker. It is still a tiny extension, but now it feels more like a useful ChatGPT utility.

You can get it from the Chrome Web Store here.

And the source is on GitHub: https://github.com/deepakness/no-thanks-chatgpt

I will be adding more features soon.

Hardening a VPS with Tailscale

2026-06-08T03:28:52Z

I recently hardened this Hetzner VPS after realizing that keeping admin panels open to the whole internet is just unnecessary risk. And honestly, @levelsio gave me the idea to use Tailscale from a few posts he made about this on X.

On this VPS, I still have a few WordPress sites hosted through a control panel, and I wanted to make the server safer without deleting websites, moving data, or breaking normal access.

The main idea was simple: websites stay public, admin access becomes private. Ports 80 and 443 stay open because visitors need them. DNS, public web traffic, nothing changes from the outside.

But the control panel on its admin port, the web server admin panel, and SSH don't need to be open to every random scanner on the internet. Those are management interfaces, not public website features.

Tailscale gives the VPS a private network address that only approved devices can reach. So I can open the control panel from my computer through the Tailscale IP, but someone scanning the public VPS IP cannot hit the login page anymore.

The important part is the order. Don't close public SSH first – that's how you lock yourself out.

The safe order I followed:

take a snapshot first
then install Tailscale on the VPS and add it to your account (disable key expiry)
install Tailscale on your local machine
test that the control panel, web server admin, and SSH all work through the Tailscale IP
disable anything unused like FTP
restrict the admin ports
and only after all of that, restrict public SSH

For Tailscale, I used --accept-dns=false because I didn't want it changing DNS behavior on the VPS. This server hosts websites and mail, so the change needed to be narrow: add private access, don't surprise anything else.

For SSH, I used a rollback safety net: a systemd timer that automatically reopens public SSH after 3 minutes if I got locked out. After removing public SSH, I immediately tested both Tailscale SSH (should work) and public SSH (should fail). Only after confirming Tailscale SSH works, cancel the rollback timer.

A few things to remember: keep cloud console/rescue access available as a backdoor, keep Tailscale running on your machine before trying SSH or admin panels, firewall rules aren't active until you reload, and always test websites after any firewall change.

This isn't the same as rebuilding a compromised server. It's a practical hardening pass. But for a VPS that needs to keep running websites, it's a big improvement: keep the public web public, and make the sensitive admin stuff reachable only from your own devices.

Using the Composer 2.5 model in Pi agent harness

2026-06-02T14:25:47Z

Cursor released the Composer 2.5 model a while ago, and it's very capable model while being super cheap. And since I also love the Pi coding agent, I wanted to use the Composer 2.5 model inside Pi and found the perfect solution for it.

It's called pi-cursor-sdk and is created by Mitch Fultz. It uses the official Cursor SDK so Cursor's agent loop and tools are still used when using the model via the Pi agent. And it's a great thing because Cursor has one of the best agent harnesses out there.

I have been using it for the last few days, and it works flawlessly.

Trying the new MiniMax M3 model via OpenCode

2026-06-02T06:11:23Z

MiniMax M3 was released a day ago, and currently it's available in OpenCode for free for the last 2-3 days (yes, from even before the release). I, finally, gave it a try and it's so good, at least at UI design.

For example, I created this website using just two prompts (will share below) and it looks stunning. I am damn sure that Codex could never do this, and it's just Opus 4.8 level design but a lot cheaper. I have also taken a full page screenshot that you see here.

And if you're curious, prompts were:

Prompt 1:

create a stunning personal website for a developer. use dummy info. don't use any framework.

Prompt 2:

make it in light mode and don't use serif fonts. and make the design and ui even better.

After seeing it work great at the UI design, I asked it to redesign the entire dashboard for a new project I am working on, and it did a great job. I approved the plan and left it overnight, where it should have worked for a few hours and then when I woke up in the morning, it was ready. It had several minor errors which Codex quickly fixed, and I loved the overall UI and UX it did. I will soon be merging the new branch to the main.

For all these things, I used it for free via OpenCode (for a limited time), but if you wanted to try MiniMax M3, they have a very generous plan on their official website. Their $20/mo plan can get you up to ~1.6 billion tokens when you use the new M3 model. MiniMax has also released a desktop app called MiniMax Code and is currently available for macOS as well as Windows. It looks very similar to the Codex app, though.

By the way, since MiniMax M3 is an open-weight model, you can also try the new model via any other inference provider like OpenRouter and others.

Pi agent lessons from Dillon's shared session

2026-05-30T23:49:27Z

I spent some time reading Dillon Mulroy's shared Pi session, and honestly, I learned more from the workflow than the docs.

The main thing I noticed is that he doesn't use Pi like a quick code generator. He uses it more like a supervised senior implementation partner. The agent is not just asked to "build this thing". It is given specs, constraints, examples, review notes, and a clear process.

A few things I want to copy in my own Pi workflow.

1. Write the spec first

Before asking Pi to implement a large feature, create a small but clear tech spec with goals, constraints, routes, data model, edge cases, and test plan.

2. Add working-style rules to AGENTS.md

My current AGENTS.md has tool preferences and writing style rules. I should also add how I want to work – something like "prefer 3–5 small focused prompts over one large prompt", or "never rewrite a file without showing me the diff first".

3. Do architecture review before coding

Instead of directly saying "rebuild this", first ask Pi to inspect the existing files and explain where the design is weak, where cohesion breaks, and what should be changed.

4. Ask for call graphs and seams

Before implementation, ask Pi to sketch the public API, call graph, injected seams, and production vs test adapters. This makes bad design visible before code is written.

5. Use skills for methodology

A simple prompt like "use TDD" is weaker than a full TDD skill. Dillon injects an inline <skill> block that defines the philosophy, anti-patterns, and step-by-step workflow. I should create or reuse small skills for TDD, review, UI polish, refactors, and audits.

6. Use vertical slices

One failing test, one small implementation, one passing check. Don't ask the model to build the whole dashboard or whole feature in one go.

7. Give hard constraints

Prompts should include rules like: no new package, no mock data, no broad rewrite, no nullable return, no touching unrelated files. This keeps the agent on a tighter leash.

8. Use markdown annotations for review

Instead of explaining everything again, paste notes like this and ask Pi to apply only those changes:

## Markdown Annotations
- Section 4.1: update status to "implemented"
- Line 42: rename `fetchUrl` to `resolveShortLink`
- Section 3: remove the assumption about Cloudflare D1 – it's now R2

9. Codify mistakes permanently

When Pi makes the same kind of mistake, don't just fix it once. Add the rule to AGENTS.md so future sessions inherit it.

10. Use reference repos

For framework-specific work, keep local clones or examples and ask Pi to read those first. Real examples are better than model memory.

11. Use the session tree properly

If a design exploration is risky, fork the session. If it goes wrong, abandon that branch instead of trying to repair a messy conversation.

12. End with a handoff

At the end of a longer task, ask Pi for what changed, tests run, files modified, open issues, and the next 5 todos.

This is probably the biggest takeaway for me:

Better agent results come less from one perfect prompt and more from a better engineering loop.

The loop should be something like:

review the existing design
→ sketch options
→ agree on the shape
→ write or update the spec
→ implement one vertical slice
→ run checks
→ review with annotations
→ save new rules in AGENTS.md
→ hand off clearly

I already use Pi with DeepSeek, web access, goal tracking, and vision proxy, and I wrote about that setup in my Pi coding agent setup post. That setup is working nicely, but Dillon's session made me realize that it is still mostly tool-focused.

The next improvement is process-focused – better specs, better review loops, better constraints, and better handoffs.

Setting Up and Using the Pi Coding Agent

2026-05-29T17:04:47Z

I have been using AI coding tools for a while now. At the time of writing this, I am subscribed to both Cursor and OpenAI Codex. They are great at what they do and I use them for most of my main project work.

But over 2 weeks ago, I came across Pi – an open-source terminal coding agent. It has a small core and lets you add features through extensions and packages, instead of packing everything in by default. I liked the idea, so I decided to set it up and see where it fits.

I am still figuring out the right balance, but Pi has already found a place for my side projects and experiments. In this post, I'll share how I installed it, what my setup looks like, and my honest experience so far.

What is Pi?

Pi is an open-source terminal coding agent created by Mario Zechner. It works in your terminal and gives the AI model four tools by default – read, write, edit, and bash – to work with your codebase.

There is no built-in plan mode, no sub-agents, no MCP, and no permission popups. Instead, you can add these things through extensions, skills, and packages. This keeps the core small and lets you build exactly the setup you want.

Pi works with many AI providers – Anthropic, OpenAI, DeepSeek, Google Gemini, Groq, xAI, OpenRouter, Kimi, and more. You can use an API key or log in with an existing subscription.

How I use Pi alongside other tools

Right now, I use different tools for different kinds of work:

OpenAI Codex for complex tasks on my main projects
Cursor for simpler day-to-day coding on those same projects
Pi for side projects, experiments, and one-off tasks – I pair it with DeepSeek, Kimi, Cursor (via pi-cursor-sdk), and whichever model fits the task

Pi feels right for side projects because it's fast, lightweight, and I can use cheaper models without burning through expensive subscriptions.

One example: I recently used Pi with the DeepSeek v4 Flash model to scrape 285K URLs from a website. It ran for about 1.5 hours and cost me just $1 through the official DeepSeek API. I used the pi-codex-goal extension to track the long-running task and it worked without issues. You can read more about this on X.

Installing Pi

Installation is one command:

curl -fsSL https://pi.dev/install.sh | sh

Once installed, start it by typing pi in your terminal. But first, you need to set up a provider and API key.

Setting up DeepSeek as the provider

Pi has a built-in /login command that makes setting up any provider easy. Here is what I did:

Opened Pi by typing pi in the terminal
Typed /login and chose Use an API key
Selected DeepSeek from the providers list
Entered my DeepSeek API key when asked

That's it. Pi saves the key and you're ready to go. After logging in, use /model to pick your model – I chose deepseek-v4-pro with xhigh thinking.

I default to xhigh thinking because I want the model to think deeply before making changes. For lighter tasks like the URL scraping, I switch to the faster and even cheaper deepseek-v4-flash model.

You can open the model picker with Ctrl+L, cycle through your scoped models with Ctrl+P, and change the thinking level with Shift+Tab.

I also use Kimi K2.7 Code and other models depending on the task – more on that in the model lineup below.

My model lineup

I have several models enabled and switch between them depending on the task:

Model	What I use it for
DeepSeek v4 Pro	Default for most side project work – good balance of quality and cost
DeepSeek v4 Flash	Lighter, repetitive tasks like scraping or bulk file operations – fast and cheap
Kimi K2.6 / K2.7 Code	Alternative when I want a second opinion or hit rate limits
Cursor (via pi-cursor-sdk)	Lets me use my existing Cursor subscription inside Pi without an extra API key
OpenAI Codex (GPT-5.5)	Occasionally when a task benefits from a larger reasoning model

Switching is instant – Ctrl+L opens the model selector, and Ctrl+P cycles through scoped models.

The interface and my custom footer

When you open Pi, the interface is clean. The editor is at the bottom, the conversation in the middle, and the footer shows your working directory, git branch, current model, thinking level, and context window usage.

One thing I customized early on was the footer. The default footer shows more information than I need. So I asked Pi itself to build me a custom minimal footer. I described what I wanted – current folder, git branch with a dirty marker, model name, thinking level, active goal from pi-codex-goal, and a compact context bar – and it wrote the TypeScript extension for me.

The extension lives at ~/.pi/agent/extensions/minimal-footer.ts and Pi loads it automatically on every startup. I have also put the code in a gist — just drop it into the extensions folder and restart Pi. It was a small change but it made the experience feel personal. I also learned a bit about how Pi extensions work in the process.

Packages I installed

Pi packages are npm or git packages that bundle extensions, skills, prompts, and themes. You install them with pi install. Here are the ones I use:

1. pi-web-access

This package gives Pi the ability to search the web, fetch page content, extract YouTube video transcripts, and explore GitHub repos. You can find it at pi.dev/packages/pi-web-access.

pi install npm:pi-web-access

It works out of the box with Exa search (no API key needed), and you can optionally add API keys for Perplexity, Exa, or Gemini for more control. I configured it to use Exa as the default search provider by creating a ~/.pi/web-search.json file:

{
  "provider": "exa",
  "allowBrowserCookies": false,
  "summaryModel": "deepseek/deepseek-v4-flash",
  "workflow": "none",
  "curatorTimeoutSeconds": 20
}

With this package, Pi can search the web, read documentation, understand YouTube videos, and clone and explore GitHub repositories – all without leaving the terminal.

2. pi-codex-goal

This package adds goal tracking to Pi. It's built by Mitch Fultz. It gives the model three new tools – get_goal, create_goal, and update_goal – that let you create long-running tasks and track progress.

pi install npm:pi-codex-goal

I use this whenever I have a bigger task that spans multiple prompts. Instead of repeating the context each time, I create a goal once and Pi keeps track of what needs to be done. It was especially useful during the 285K URL scraping task – the goal kept the task on track even when the session got long.

3. pi-vision-proxy

DeepSeek cannot look at images – it has no vision capabilities. The pi-vision-proxy package fixes that by proxying images to another model that does have vision.

pi install npm:pi-vision-proxy

I have set up Kimi K2.6 as my vision model. Now, whenever I paste an image into Pi, it sends the image to Kimi with some context, and then DeepSeek uses what Kimi saw to finish the task. It works well for the occasional screenshot or design reference I throw at it.

Under the hood, it batches multiple images when possible and caches repeated screenshots using perceptual hashing so the same image isn't re-analyzed. It also supports several grounding formats for precise coordinate targeting when needed. You can read more about this setup on X, and I also have a short video in the X post as well.

4. pi-agent-browser-native

This package gives Pi a real browser inside the terminal. It can open pages, take screenshots and snapshots, click links, fill forms, run QA checks, and extract page content – all without leaving the terminal.

pi install npm:pi-agent-browser-native

I use this alongside pi-web-access. Web search finds the information, and the browser lets me interact with live pages, read documentation on sites that need JavaScript, and check things visually. It also adds the agent_browser_web_search tool, which is a quicker way to search the web than opening a full browser page.

5. pi-cursor-sdk

If you already pay for a Cursor subscription, this package lets you use it inside Pi so you are not paying twice.

pi install npm:pi-cursor-sdk

I have a Cursor subscription and this was a natural fit. After installing, cursor/auto shows up as a model option in the picker and I can use it just like any other provider. It is also built by Mitch Fultz, the same person behind pi-codex-goal. Between Cursor for subscription models, DeepSeek for cheap heavy lifting, and Kimi as an alternative, I have good coverage without adding more API bills. I wrote more about using the Composer 2.5 model through this SDK in my raw notes.

Project instructions with AGENTS.md and APPEND_SYSTEM.md

Pi has two ways to give the model instructions: AGENTS.md for project-specific context, and APPEND_SYSTEM.md for global behavioral rules.

AGENTS.md (project context)

Pi loads AGENTS.md files at startup and injects them into the system prompt. There are three discovery locations – a global one at ~/.pi/agent/AGENTS.md, then parent directories walking up, and finally the current directory – and they're all concatenated together.

I keep my global AGENTS.md minimal. It only describes what stack I typically work with:

# Global Pi Instructions

- Projects commonly use Laravel (PHP/Inertia/React), Next.js
  (TypeScript/Tailwind), or Astro. Check the project-root AGENTS.md for
  stack-specific rules – if none exists, ask.

The "if none exists, ask" part is important. When I'm working in a plain HTML/CSS/JS folder or some other stack, the agent doesn't force a framework on me – it just asks.

Most of my projects also have their own AGENTS.md with framework-specific rules, but I rarely write them by hand. They're generated by the framework tooling (like Laravel Boost) with the exact package versions and conventions for that project.

APPEND_SYSTEM.md (global behavioral rules)

AGENTS.md is for project context, but some rules apply across every project regardless of stack. That's where APPEND_SYSTEM.md comes in. It lives at ~/.pi/agent/APPEND_SYSTEM.md and gets appended directly to the system prompt – which means these rules carry higher authority than AGENTS.md instructions.

Here's what I put in mine:

- If the default provider doesn't have vision capabilities, use
  pi-vision-proxy for images.
- Read relevant local files first when the answer is available in the
  codebase. If not, research online via pi-web-access. Before making a
  big change based on online research findings, confirm with me first.
- Explain risky file edits and destructive commands before executing.
- Write simply. Avoid AI-slop language – no flowery adjectives,
  unnecessary adverbs, or overly formal phrasing.
- Use en dashes (–) not em dashes (—).

A few notes on these rules:

The vision proxy rule is now provider-agnostic. I might use Kimi, DeepSeek, or another model as my default, so instead of hardcoding a provider name, it checks whether the current model has vision capabilities.
The second rule is more explicit than my earlier version. Instead of just saying "don't search for things you already know", it tells the agent to read local files first, search online only when needed, and confirm before making big changes based on online research.
The en dash rule is a simple mechanical preference that keeps my writing style consistent across all sessions.

Keyboard shortcuts and commands I use

Pi has many shortcuts. Here are the ones I use regularly:

Key	What it does
`Ctrl+L`	Open the model selector
`Ctrl+P`	Cycle through scoped models
`Shift+Tab`	Change thinking level
`Ctrl+C` (twice)	Quit Pi
`Escape`	Cancel or abort the current action
`Enter`	Send as a steering message (interrupts current work)
`Alt+Enter`	Send as a follow-up message (delivered after work finishes)

The difference between Enter and Alt+Enter took some time to get used to. If I want Pi to change direction mid-work, I press Enter. If I just want to add a note for after it finishes, I use Alt+Enter.

And these are the commands I use, often by typing / in the editor:

/model – Switch models without remembering the shortcut
/settings – Change thinking level, theme, and other settings
/resume – Pick up from a previous session
/new – Start a fresh session
/tree – See the full session history and jump to any point
/compact – Summarize old messages to free up context
/session – Show current session info like tokens and cost

The /tree command is especially useful. You can see your entire conversation history like a tree, jump to any branch, and continue from there. It's great when you want to try a different approach without losing what you had before. I got very curious about it after coming across this shared Pi session from Dillon Mulroy. I later wrote down everything I learned from that session in my raw notes.

A few things I learned while using Pi

Long sessions fill up the context window. Pi has automatic compaction that summarizes older messages when you're running out of space. You can also do it manually with /compact. And I love the pi --continue command, that directly opens the last chat in the repo/folder.

Another thing I like is the steering system. While Pi is working (running bash commands, editing files, etc.), you can type a new message and press Enter. This queues a steering message that gets delivered after the current tool finishes. I use this when I notice Pi going in the wrong direction mid-work and want to correct it quickly. Sometimes, instead of a steering message, I also do Option+Enter that sends the message after previous output is completely finished generating.

You can also use your OpenAI Codex subscription inside Pi, Cursor subscription via pi-cursor-sdk, 100s of models via OpenRouter, xAI, Claude and many more providers via API.

Things I like about Pi

After using Pi for a few weeks, here's what stands out:

Simple and fast: The terminal interface is snappy. No Electron, no UI lag.
Customizable: I built the exact footer I wanted, picked the packages I need, and the rest stays minimal.
Works with any provider: I use DeepSeek and Kimi regularly, and switching between them is one shortcut away. I also learn a lot when using it – you get closer to how things actually work, unlike more polished tools where everything is hidden.
Session tree is brilliant: Being able to branch conversations and go back to any point is something I miss when using other tools.
Open source (MIT): I like that no company decides what features I get or how much I pay.
Compaction just works: I don't think about context limits. Pi handles it in the background, and faster and better than others.

Final thoughts

I am still using Cursor and Codex for my main project work, and I don't see that changing anytime soon. They are polished tools that do their jobs well.

But Pi has earned a permanent place for my side projects and experiments. It's fast, it's cheap (especially with DeepSeek and Kimi), and the combination of Pi + a few well-chosen packages has been solid so far.

Here's what my current setup looks like:

DeepSeek v4 Pro with xhigh thinking (default)
DeepSeek v4 Flash for lighter tasks
Kimi K2.6 / K2.7 Code as alternative models
pi-web-access for web search and content extraction via Exa
pi-codex-goal for tracking longer tasks
pi-vision-proxy to handle images via Kimi K2.6
pi-agent-browser-native for browser tasks in the terminal
pi-cursor-sdk to use my Cursor subscription inside Pi
APPEND_SYSTEM.md with writing style and behavior rules
A custom minimal footer extension

That's it. I tried more packages but kept only what I actually use.

If you are comfortable in the terminal and like the idea of a minimal, extensible agent, give Pi a try. Start with the basics and add packages as you feel the need.

I have been using Pi for a few weeks now and the setup is stable. I uninstalled a few extensions that didn't add enough value. The simpler the setup, the better.

I will keep updating this post as I discover new things about Pi.

Update: July 21, 2026

Recently, I am using my Cursor subscription inside Pi a lot via the pi-cursor-sdk extension. I am mostly using the Composer 2.5 model for simple long-running tasks as /goal via the pi-codex-goal extension.

In just past few days, I have used more than 1.5 billion tokens of the Composer 2.5 model (thanks to the 50% discount till 21st July, i.e., today).

Cheaper coding models are excellent with good prompts

2026-05-29T12:17:10Z

Dan posted about cancelling Cursor after 30 minutes of using Composer 2.5, and while the wording was too harsh, I don't think the frustration itself is completely wrong.

I posted about this on X as well, but I think the main thing people miss is that cheaper or smaller models need to be prompted differently.

You can't prompt DeepSeek, Kimi, GLM, Composer, Qwen, or other similar models the same way you prompt Claude Code or Codex.

With Claude Code and Codex, especially with the latest models, you can throw a broad task at them and expect the model to explore the repository, understand patterns, implement the feature, run tests, and come back with something mostly correct. It will still make mistakes, obviously, but it can handle much more ambiguity.

But these cheaper models are not great at that kind of one-shot work.

If you ask them to "build this full dashboard", "rework the entire app", or "implement this complete feature end-to-end", the result is usually messy. They will often do too much, miss existing patterns, break small things, or create a UI that looks good in one part but doesn't fully fit the app.

But if you go feature-by-feature or page-by-page, they can be excellent.

For example, instead of saying:

Build the entire analytics dashboard with filters, charts, empty states, settings, export, and responsive UI.

I would rather ask:

create the empty dashboard layout
add only the filters section
create the first chart
add loading and empty states
make the table work
polish spacing and mobile layout
now review the whole page and fix rough edges

This is a different workflow. You need more patience. You need to be more involved. You need to keep the model on a tighter leash.

But the tradeoff is worth it in many cases because these models are cheap and fast enough that iterating with them still feels good.

A few days ago, I built a small internal feature for SharePDF using DeepSeek V4 Pro via Pi agent. And honestly, the UI was far better than what Codex usually gives me, and everything worked as expected as well. But I didn't ask it to rebuild the whole product in one prompt. I gave it a smaller scope, checked the output, and then continued from there.

This is why I still think models like Composer 2.5, DeepSeek, Kimi, GLM, and Qwen are very useful. In fact, I have already written that Cursor's Composer 2.5 is awesome and that Cursor's $20 plan is great value. That doesn't mean the model will behave like Claude Code or Codex in every situation.

Sometimes when you have the option, there is no point using the cheaper model. If I'm doing a complicated refactor, touching billing logic, debugging something subtle, or making a change across many files, I would still prefer the best model I have access to.

But if I'm designing a page, improving UI, adding a smaller feature, or doing something where I can review each step quickly, I don't mind using cheaper models at all. In some cases, I even prefer them. I still consider Qwen 3.7 or even 3.6 Plus models far better at design than GPT models.

So I think the correct conclusion is not "Composer is bad" or "DeepSeek is bad" or "cheap models are useless".

The correct conclusion is:

don't use a cheaper model like a SOTA model.

Use Claude Code or Codex when you want more autonomy. Use DeepSeek, Kimi, GLM, Composer, or Qwen when you are willing to drive more actively.

Both can be great. You just can't expect the same prompting style to work everywhere.

Cursor's $20 plan offers the best value for month

2026-05-27T17:37:42Z

I last used Cursor in January this year, because it later started seeming too costly. But after their Composer 2.5 model release, I tried Cursor again after 5 months and I loved it a lot. I have been using it for a little over a week now, and it's the best model for the price out there.

At the time of writing this post, I have used over 430 million tokens in total where almost 320 million tokens are only from Composer 2.5, as you see in the screenshot above.

I have written a post on X about things I like about Cursor and then things I don't.

By the way, I am only on the $20/mo plan for Cursor Pro, and then I have only finished 54% of the monthly limits as of now. I am surprised how good the limits are even on the $20 plan, and I must say, again, that Composer 2.5 is a great model.

Fixing Cursor app's too much resource usage

2026-05-26T05:25:19Z

Cursor app had become weirdly unusable on my Mac recently, and I couldn't figure out why. So I asked Codex to do a read-only audit of my computer and create a small HTML report.

Turns out Cursor itself was not exactly the problem.

Cursor was launching an old Telegram MCP/plugin process from my ~/.claude folder, and that orphaned bun server.ts process was eating a lot of CPU in the background.

The funny part is, I don't even use that Claude setup anymore.

So I deleted ~/.claude, cleared Trash, and still the process kept running. That was the interesting bit: deleting files does not stop an already running process.

Codex then traced the exact PID, stopped only that orphan process, verified it didn't come back, and updated the report with what happened.

Now Cursor is normal again.

The main lesson for me: agent config is not harmless. Old MCP/plugin setup can keep affecting other tools long after you forgot it exists.

Also, I still don't fully understand why Cursor was launching something from my old Claude folder in the first place. But this is exactly why stale agent config feels like technical debt now.

Cursor's Composer 2.5 is awesome

2026-05-22T20:16:44Z

I last used Cursor in December last year, and after hearing great things about the new Composer 2.5 model, I decided to give it another try after 5+ months. While my experience is mostly positive, I will be writing about things I liked as well as things I didn't like.

What I liked:

Composer 2.5 model is fast, even when using without the fast mode. Most of the things I work on, just take seconds and sometimes a few minutes, making it faster than Codex or Claude models I have used in the past.
The 2.5 model is cheap, cheaper than all its competitors, actually. I used ~100 million tokens in a day and that resulted in only ~7% usage of the monthly limit, as you see in the screenshot here. I have posted on X about it in detail.

For your information, I am subscribed to the Cursor Pro plan which costs $20/month. And they're currently running a 2x offer for the week, but I think it's still a great value for money even after the offer ends. When I last used Cursor, the $20 plan was basically nothing when using any decent model. But that's not the case anymore, Composer 2.5 is a great model and that makes Cursor a great subscription plan right now.

What I didn't like:

I'm using a MacBook Air M2 with 16 GB of RAM and the Cursor app is just consuming too much resources, so much that the laptop is constantly running hot. I have heavily used Codex or Claude Code app but never had this issue earlier, so it's clear that they need to optimize the app for performance.

This was so serious that I ditched the app, and currently using the Cursor CLI only. It's great, I am loving it, and have even created a custom /statusline for myself.

My advice for others:

If you're confused about whether you should subscribe to Cursor, I would strongly suggest giving it a try. The Composer 2.5 model is amazing and can do most of your work.

As per calculations from my usage, if you're using 50 million tokens per day by using the Composer 2.5 model, the $20 plan will last for ~24 days before you exhaust your monthly limit. And this is great for people working on one or two projects simultaneously.

And if you can get the $60/mo plan, it's even better.

My experience with Antigravity 2.0 (it's bad!)

2026-05-20T02:35:30Z

Google I/O 2026 happened and Google announced a bunch of interesting things in the event. One thing I was particularly interested in was the new Antigravity 2.0, as I loved using the tool and coded the first versions of SharePDF by using this only in December-January this year.

But the new IDE didn't live up to my expectations, and it's bad!

So... let's look at everything bad one-by-one for the new Antigravity app:

1. Couldn't log in for hours

As soon as they announced Antigravity in the event, it was available for download. I updated the existing Antigravity app, and it got logged out when the new app opened. I tried logging in multiple times, but I kept seeing auth errors.

I kept seeing the above screen no matter how many times I tried. After an hour or so, the authentication successfully worked but when I quit and reopened the app, it started having the same issues again.

But it finally worked when I used it after several hours.

2. Keep asking for approvals

I have set Auto Execution and Review Policy options to "Always Proceed" as you see in the screenshot below, but it keeps asking for approvals each time.

And this is just an example, I had to approve at least 20 times for a simple HTML page I asked it to create. I have given "Full Access" to it, but this is still happening.

At least this wasn't happening on the Antigravity 1.0, right?

3. Creates lots of unwanted HTML files

I asked it to create a personal website for me by taking the required data from my existing website, but to be precise this was the exact prompt:

Create a clean and minimal personal website for me.
Take whatever info you need from my existing website: deepakness.com

And while it created the website using HTML, CSS, and JavaScript, it also created a bunch of temporary HTML files in the folder. I confronted, then it said that those can be safely deleted.

4. No plan mode anymore

I don't see the plan mode anywhere in the IDE, the dropdown we had earlier for planning/fast modes, no longer appears to be there.

5. Creates SPA all the time

When you don't mention the tech-stack, it always creates websites as SPA (single page applications). For the personal website sample project I created earlier:

All views (#home, #projects, #about, #newsletter) live in a single index.html and are toggled via JavaScript (navigateTo() in app.js) without full page reloads. It uses hash-based routing (#home, #projects, etc.) and content is dynamically shown/hidden client-side.

I tried the same prompt (from #3 above) at least 5 times, it created SPAs every time.

6. Has a bad design taste

I thought that the new model will have a great design capabilities, but it does not! It's still all purple, as you see in screenshots here.

I blame the Antigravity harness here, because designs are slightly better when I used the same prompt in the Google AI Studio.

7. Antigravity CLI also has bugs

To be honest, the Antigravity CLI is far better than the previous Gemini CLI and it's better than the Antigravity app as well. But it also has some bugs:

the prompt input field sometimes disappear
the scroll doesn't work at all sometimes
keeps asking for approvals, even after setting everything as "Always Proceed"

8. Other people sharing their experiences

Here are some posts by other people who have shared about Antigravity, that I found while browsing the internet:

Robin created a quick video on X sharing how bad his experience was.
The new 3.5 Flash model is very costly as well, as shared by someone on X.

Now, here are some things I liked:

I liked the multi-folder options for projects, as I can give access to multiple folders without giving access to the entire computer.
Usage limits for the new models are slightly higher than earlier on the AI Pro plan, and I think they have also added 1,000 extra AI credits for everyone.

That's it.

I will keep updating this page as I discover more things I like or dislike.

AI Search Optimization Skill as per Google's guidelines

2026-05-16T18:55:36Z

Recently, Google published a detailed guide on optimizing your website for generative AI features on Google Search, including a lot of interesting information. I came across this from this post on X from Gagan Ghotra, and created a powerful skill by consulting Gagan.

I published the skill in this public GitHub repo, and it can be accessed, installed, and used by anyone by following the provided instructions. And also created this quick video for beginners where I'm showing how to set up and use the skill (the same video on X).

Over the next few days, I will also be using the skills on different personal projects and will keep improving as per my experience with it. But since the GitHub repo is public, other people are also welcome to contribute.

And not to mention, the skill can be used with almost any AI agent/harness we have out there.

Freeing 100+ GB of storage on macOS using Codex

2026-05-16T13:02:31Z

I still use the MacBook Air M2 with 16 GB of RAM and only 256 GB of storage, and it was working perfectly fine for my use case until recently. I started getting the low storage warnings sometimes, and that annoyed me a lot. And I was about to factory reset my laptop... but then at the last moment, I decided to ask Codex about it, and glad that I did.

Codex helped me free more than 100 GB of storage by deleting unnecessary stuff that were there from some apps that I used and deleted earlier. For example, I once tried a local model via Hugging Face and LM Studio and they were together taking 35 GB of storage. Similarly, I tried a Docker alternative called Colima and it was taking another 19 GB, as you see in the screenshot here.

It also gave me suggestion to remove folders from the ~Library/Application Support/* from apps which were not used or not installed on my system anymore. From here, you can see that I try a lot of applications like browsers and so on.

Application Data on macOS" decoding="async" src="https://assets.deepakness.com/raw/codex-macos-cleaning/library-application-data.png">

The screenshots you see above, is from an HTML file that I asked Codex to create after analyzing my laptop in detail. And it created a complete checklist with all the information that I can do to optimize my laptop. It did a great job.

Now, the funny thing is I earlier used Mole and even subscribed to the CleanMyMac app and there also weren't able to free these unnecessarily occupied storage. I tried them a few times, and they only cleared a maximum of 5-10 GB storage.

Another funny thing is, I have used Linux for years in the past and I know about the file systems a bit. But I have become lazy ever since I started using macOS (I love my MacBook though) and didn't even bother to check those folders. But after Codex gave suggestions, I went and deleted unnecessary folders and files by myself, and cleared over 100 GB of storage.

Life's good now!

SharePDF now has 200 users

2026-05-12T17:37:28Z

I started working on SharePDF in January 2026, and it's been an amazing journey. It took ~4 months to reach 100 users, and now we're looking at 200 users in just 20 days after that.

Crazy, right? At least for me.

And in the last few weeks, I have also added enhanced existing stuff and have also added a few more features to the app. Some improvements done were:

Added a way to replace PDFs while keeping the same old share link
Introduced collections, a way to better manage lots of PDFs for power users
Improved analytics, so now users can see more data points, including per PDF analytics as well
Improved custom domain, billing, support, uploads, reliability, etc.

And still working to make everything even better for users.

Also, wrote a new blog post listing all the cool features SharePDF now has. I have tried to include everything here, and will probably keep this updated as well.

Apart from this, I am also launching SharePDF on Product Hunt tomorrow, i.e., May 13th at 12:30 IST. And I request your support for the launch, if you're reading this.

Thank you!

Run NVIDIA Kimi K2.6 and others in OpenCode

2026-05-10T07:41:09Z

I wanted to use Kimi K2.6 from NVIDIA inside OpenCode, and it was simpler than I first thought. This and a bunch of other open-source models are free to try in NVIDIA, by the way.

I only had to add the API key, model details, and the correct base URL in the OpenCode config.

I wanted to try Kimi K2.6 but you can try other models as well. For Kimi, NVIDIA's model name is:

moonshotai/kimi-k2.6

But inside OpenCode, I had use it like below

nvidia/moonshotai/kimi-k2.6

I edited this file on my macOS device:

~/.config/opencode/opencode.jsonc

And added this config:

{
  "$schema": "https://opencode.ai/config.json",
  "model": "nvidia/moonshotai/kimi-k2.6",
  "provider": {
    "nvidia": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "NVIDIA",
      "api": "https://integrate.api.nvidia.com/v1",
      "options": {
        "baseURL": "https://integrate.api.nvidia.com/v1",
        "apiKey": "YOUR_NVIDIA_API_KEY_HERE",
        "timeout": 600000,
        "chunkTimeout": 60000,
        "extraBody": {
          "chat_template_kwargs": {
            "thinking": true
          }
        }
      },
      "models": {
        "moonshotai/kimi-k2.6": {
          "name": "Kimi K2.6",
          "reasoning": true,
          "tool_call": true,
          "temperature": true,
          "attachment": true,
          "interleaved": {
            "field": "reasoning_content"
          },
          "modalities": {
            "input": ["text", "image", "video"],
            "output": ["text"]
          },
          "limit": {
            "context": 262144,
            "output": 65536
          },
          "options": {
            "chat_template_kwargs": {
              "thinking": true
            }
          }
        }
      }
    }
  }
}

The important bit is this URL:

https://integrate.api.nvidia.com/v1

NVIDIA's example uses the full /chat/completions URL, but OpenCode only needs the base URL. It adds /chat/completions by itself.

Works as expected, so that's it.

Laravel installer getting killed after update

2026-05-06T16:50:15Z

I ran into this after updating Laravel / Herd Lite using the php.new installer. The update itself looked successful, but when I tried creating a new Laravel project, the command was immediately killed by macOS.

Initially, it looked like a Laravel installer issue because I also saw a PHP parse error from inside the Laravel installer PHAR. But the actual issue was lower-level: the bundled PHP binary was getting blocked/killed when running from Herd Lite's installed bin directory.

The fix was to download fresh PHP, Composer, and Laravel installer binaries and place them in a clean local bin directory. Then I updated my shell PATH so this clean directory is used before the problematic Herd Lite bin path.

In short:

export PATH="$HOME/.local/herd-lite-bin:$PATH"

After reloading the terminal, php, composer, and laravel resolved to the working binaries, and laravel new started working again.

So if Laravel commands suddenly start saying zsh: killed after a Herd Lite / php.new update, check where your php and laravel binaries are coming from first.

From free tools to full SaaS

2026-05-06T01:10:16Z

I created a free tool a few months ago, and now it's getting 10-15 clicks every day from Google, as you see in the screenshot here. So... I researched a bit and realized that there is a solid SaaS opportunity on the site, I can have the main tool free but then can also build some paid features in the web app.

And not just this, take a look at another free tool I created before ChatGPT was launched, and it's still getting lots of traffic from Google and other referrers. Take a look at the screenshot here:

This one is getting 80-140 clicks a day consistently for years now, and I haven't done anything with it yet, but not anymore. I am working on it to bring some paid offerings in the app, currently, in the brainstorming phase. For research, I am analyzing other similar apps and also going through the data from Google Search Console, and it's been very helpful so far.

If you're wondering, I am not going to tell you what the app is about just yet because it's very simple, and the idea can be copied with just a prompt. But yes, I will eventually share more about these.

Honestly, "distribution" has always been important, but it has become even more important in the age of AI because "code" is not the moat anymore. In my case, I already have thousands of visitors coming to the tool and if I create the paid version, I will instantly have lots of potential customers.

Also, the concept of engineering as marketing is the most rewarding than ever in the current time, because creating free tools around your main product is simpler and faster than ever. If you want to experiment something with the lowest effort, just ask any LLM to give you ideas for free tools around you main product, create one, publish it in a subdomain, and forget it for a few weeks. If you see a positive traction, create the tool on the main domain, and do a redirect from the subdomain.

I think, this is the best use-case of AI for marketing.

Save a clipboard image to computer on macOS

2026-05-01T16:25:54Z

I take a lot of screenshots and most of the time keep them in my clipboard and then paste wherever needed, like on socials or in AI coding tools when working. But sometimes, I also need to save those images locally on my computer, and till now I have been doing one of these two things:

Either take the screenshot once again, or
Paste images somewhere like on Imgur, and then save by using "save image as" feature

Silly, but yes.

However, I recently found out a trick that works like a charm, at least on macOS. The process is:

Open the Preview app, you can do so by searching for Preview via Spotlight search
Press cmd + n and you should already see the image from your clipboard

Now, just save it using cmd + s or however you want to, as you see in the screenshot here.

It works as expected and even gives you image format you want to save your screenshots as.

TIL.

DeepSeek v4 Pro should be taken seriously

2026-04-30T17:01:42Z

For the last 2 days, I have been using the DeepSeek v4 Pro model via OpenCode Go and it has been a fantastic experience. I never expected the model to be this good at UI as well as logic.

For example, I am creating a custom blog publishing CMS powered entirely by Cloudflare (D1, R2, and Workers). Initially, I used Codex for this and Codex did ready the first working version, but the UI was very bad and cluttered and the user-experience wasn't great either. I didn't even like the CMS a bit.

But then I fired up OpenCode and gave everything to the DeepSeek v4 Pro model, and asked it to re-do and re-design everything by keeping user-experience in mind. I, then, went to the gym and the model had done its magic by the time I returned. It ran for ~35 mins and completed everything in one go, and the design was already looking much cleaner and just better.

I still had to give a few more prompts to refine some things, and it did everything perfectly. Just for your information, while working, I kept the thinking effort as default, as you see in the screenshot.

From the next month, I think I am going to save decent amount of money on AI tools subscriptions. Currently, I am subscribed to Codex $100 plan but now I think Codex $20 with OpenCode $10 (+ $10-20 for extra usage) should be enough for my use case.

Lastly, I think the DeepSeek v4 models should be taken more seriously by everyone. Their API pricing is also currently discounted by 75%, and there is absolutely no reason to not use this model.

Introducing EternalQR – a dynamic QR code tool

2026-04-28T03:24:11Z

Introducing EternalQR – a small web-app to create dynamic QR codes, update their links later, track scans, customize them, and download them as PNG or SVG files.

I got the idea for this from something that happened to my brother.

He had created a video on YouTube and added a QR code to it using some free QR code tool he found online. Initially, the QR code was working correctly. But later, when the video started getting lots of views, the QR code stopped working.

And because the QR code was already inside the video, there was no way to update or replace it.

That made me think that QR codes are a bit different from normal links. A link on a website can be changed anytime. But a QR code often ends up in places that are hard to edit later – YouTube videos, restaurant menus, business cards, flyers, packaging, event signs, invoices, stickers, and so on.

So I created EternalQR around one simple idea: if a QR code is already created and used somewhere, normal plan changes should not turn it into a dead link.

Some things it supports right now:

dynamic QR codes with editable destinations
scan analytics with country, device, browser, referrer, and time
QR codes for websites, contact cards, Wi-Fi, SMS, email, phone, and plain text
logo and color customization
PNG and SVG downloads
pause, expiry dates, tags, and basic dashboard management
existing QR codes keep redirecting through normal plan changes

The app is built on Cloudflare Workers, D1, and KV, so redirects are very cheap to serve. Paid plans are mainly for things like more QR codes, longer analytics history, customization, and other features.

The pricing is also kept simple:

Free – 5 QR codes
Starter – $5/mo for 50 QR codes
Pro – $19/mo for unlimited QR codes
Lifetime – $89 once for Starter features

Not to mention, but all these plans come with unlimited scans.

Here's how an already created QR code page looks, with scan analytics and more.

It's not a huge ambitious product, but just a practical tool for a problem I saw happen in real life.

Compact Tabs are back in the Safari browser

2026-04-26T20:42:27Z

I love using the Safari web browser on my MacBook, especially when I'm traveling because it consumes less battery on the laptop. But with the macOS Tahoe 26 update, the Compact tabs feature was removed from the browser, and I was sad about it.

And I'm just learning that with the new macOS Tahoe 26.4.1 update, the compact tabs feature is back in the Safari browser, as you see in the screenshot here.

It's good already, but I think it behaves a bit differently than it did in the macOS Sequoia or Sonoma, when it was still available. But it's still good, and I'm using it for a day and love it.

Thank you, Apple.

How to best spend $50 on AI coding tools

2026-04-24T16:24:36Z

I have been spending over $100 every month on Claude Max and Codex Pro plans as I use the latest models from these providers for coding, but now I don't think that's the best way to do it anymore.

The current best option I think is, instead of getting higher plan for any one AI tool, get smaller plans for multiple providers. And the best combo I can think of is the following.

Claude Pro – $20/mo
Codex Plus – $20/mo
OpenCode Go – $10/mo

Getting all these will only cost $50, but this is more than enough for my requirements. Here I will save money and also have access to top models from multiple providers. The different models can be used for different tasks that they're actually good at, for example:

for all design and UI related work – use the latest Claude models
for complex logic and programming – use the latest Codex models
for smaller tasks and everything else – use Kimi, GLM, or Qwen models via OpenCode

And not just me but several other people are also starting to realize this.

Currently, I am subscribed to Codex $100 plan that ends next month, and also to OpenCode Go plan. But I'm going to downgrade Codex to $20 plan and then also subscribe to Claude $20 plan and keep my OpenCode Go for $10.

That should be more than enough for three full-time projects I am currently working on.

My experience with the new GPT-5.5 model

2026-04-24T08:41:29Z

Yesterday, OpenAI launched the newest model GPT-5.5 which I was too excited about for the last few days. And here are my experiences so far with using the new model inside the Codex app.

GPT-5.5 is far better in frontend design than other OpenAI models like GPT-5.4 or 5.3-Codex. But it's still not at the level of Opus 4.7 of 4.6 when it comes to UI design.
Even though it was claimed by Sam Altman that the new model uses fewer tokens per task than previous models, it's not the case when I use it. In my case, it used way more tokens than GPT-5.4 because earlier I could never finish the 5-hour limit on the $100 plan, but today I did, as you see below.

The new model, GPT-5.5, definitely feels slightly faster than the previous, GPT-5.4, model in the standard mode. I think, both are equally faster in the speed/fast mode.
I didn't notice any significant improvement in the programming though with the GPT-5.5 model, it feels similarly capable as GPT-5.4 model. Or, maybe I haven't tested this enough yet.

Also, the new Codex app feels snappier and the UI and UX is slightly improved now.

Apart from this, I can still not rely completely on the Codex subscription itself. I can use OpenCode with models like GLM-5.1 and Kimi-K2.6 for frontend design and then GPT-5.5 for everything else. The OpenCode Go plan is very generous at $10/mo and has crazy limits as well. So if I had to reduce my monthly spending, I would go with OpenCode Go ($10/mo) + ChatGPT Plus ($20/mo) and maybe $20-30 extra on OpenCode, and that should cover all my requirements.

I'm still playing with the GPT-5.5 model so if I find something new worth sharing, I will keep this post updated.

Update: Apr 25, 2026

I posted about limits draining too fast on X and many people recommended that I should rarely use Extra High effort for my tasks, and suggested using either Medium or High for most tasks. So... I gave the "High" effort a try, and it's good, I am satisfied with it so far.

SharePDF reaches 100 users

2026-04-23T06:43:06Z

The app to share PDFs, SharePDF.app, that I created early this year has now reached the milestone of 100 users and I'm so happy for it. It took around 4 months to reach this milestone and I don't know what, but it makes me super happy.

I have been documenting most of the things on this page and reading previous logs takes me through the journey of things I did in the past few months – how I finalized which tech-stack to use, how I decided different features the app has, and more.

SharePDF is running stable and I don't need to do much on it now. But I still have 1-2 features or rather enhancements planned for near future. Also, I will be working on improving the landing pages as well, and maybe even create a few new ones targeting keywords that get searched a lot.

Codex is smarter than Claude Code

2026-04-21T07:07:11Z

After seriously using Codex for a few days, it definitely seems smarter than Claude Code. But Codex is just awful at design. I have tried to make good designs using Codex multiple times, and it just doesn't work. In fact, I tried creating a few new pages for my Vemgram project that I am mainly working on these days, and even though the site has a design system set up, Codex is still unable to create designs that matches the aesthetics of the rest of the website.

I am very much disappointed for that.

For this reason, nowadays, I have started using OpenCode whenever I need to design something. I love the newest launched models like Kimi K2.5, Qwen 3.6 Plus, and GLM-5.1 models inside OpenCode. These open-source models are almost as good as Opus 4.6/4.7 when it comes to design.

Apart from this, I am hearing rumors that OpenAI is about to launch GPT-5.5 and also that it's great at design. If that's the case, I won't regret subscribing to Codex Pro at all.

After Claude, now Codex can't keep up with the demand

2026-04-20T15:18:22Z

It's been almost an hour since OpenAI's Codex is completely down, as you see in the screenshot below. I recently moved away from Claude for this reason, and now I am facing the same issues here as well.

Codex still hasn't become as bad as Claude was a week ago and before that, but it seems like it's getting there. And it's surprising to me that if these AI companies can't keep up with the rising demands, why don't they just pause new signups temporarily? I mean, it will be better for everyone, no? – for users and then for their own brand image as well.

This is not at all fair for users. They're paying the premium to just experience degraded performance all the time. For example, just take a look at Claude's status chart for the last 90 days and you'll see lots of yellows and reds.

I, myself, had been paying at least $100 each month to Claude and now to Codex, but getting the same degraded performance. Honestly, I don't blame OpenAI or Anthropic for that they can't keep up with the demand, but I blame them because why are they still allowing signups and ruining the experience for everyone? They should just pause signups for some time till they get more compute, and if required pause again for some time till they get more compute, and so on.

I also run a SaaS, and I will feel very bad if I keep charging a fee to my customers and if my app is consistently down. I will even refund them and pause new signups till I get things sorted.

That's it.

Sorry for the rant, really.

I like Claude Code CLI's no flicker mode

2026-04-14T12:31:19Z

I just started using Claude Code's new no-flicker or full-screen mode for the CLI and I like it better than earlier. When enabled, it just sends the text input field at the bottom of the screen and makes it sticky. Just like how you see in the screenshot here:

I like it because it doesn't disturb me when Claude is generating a large output, then I can keep reading from the top while it outputs at the bottom, without disturbing my flow.

Mistakes were made at Google Search Console

2026-04-14T12:10:00Z

Today, I suddenly started receiving emails like below from Google Search Console for all my sites already added. These emails are normally sent when a new site is added to the GSC for tracking the search performance, but mistakes were made, for sure.

I have at least 8-10 sites added to this Gmail account and I received emails for all those in a 3-5 hour span. I also posted about this on X and several people confirmed that they have also received the same emails.

And if you're curious about the contents of these emails, see the screenshot above. It's the same that Google sends when you add a new site to GSC.

I hope they fix it soon and do not annoy me, again.

Update: Apr 15, 2026

It was just a "glitch" as everyone suspected, as confirmed by John Muller from Google. Learned about this from this post on X by Gagan Ghotra.

Introducing SharePDF app

2026-04-14T04:29:42Z

Introducing SharePDF – a web-app to host PDFs, share them as URLs, track their view analytics, and do much more. It's live and working, and already has more than 80 users at the time of writing this post.

I had this idea to create an app that makes sharing PDFs easier for at least 2 years, but I never worked on it. However, somehow I started working on it from January this year, i.e. 2026. I haven't done any kind of marketing as of now, and still regularly getting signups from sources I wouldn't even have guessed – Instagram and ChatGPT. Yes, someone must have created some content that people are discovering SharePDF from.

Today, I have also posted on X for the first time about the app. Apart from this, I have also been sharing build logs on this page on my website – it just helps me keep myself in the loop.

Currently, I am not working on new features for the app but mainly working on improving the landing page, copy, and user experience.

By the way, I also launched Vemgram, a platform to connect Indian manufacturers with buyers, a few days ago. So, now, I have two full time projects that I am working on these days.

Better utilize Claude Code limits

2026-04-11T04:01:14Z

Came across this post on X that shares a hack, a way to maximum utilize your Claude Code usage limits by setting up scheduled tasks. It seems silly at first, but it's actually helpful.

As explained in the post, I set up a cron that sends "hi" every 5 hours starting from 8AM IST so that as soon as the limit resets, it immediately starts a new cycle so that you have clean time blocks.

30 2,7,12,17 * * *

And the best thing is, you don't need any extra tool to use for this.

Meta's new Muse Spark model is here

2026-04-08T17:21:02Z

Meta just launched a new AI model called Muse Spark which is now available to use via meta.ai and the Meta app. It's not available via the API, yet.

As of now, it looks good on the evals as you see in the screenshot here. In categories, it's shown to be even better than Opus 4.6 and GPT-5.4.

I tried the model via meta.ai web interface with my Facebook login, and I must say that it has a better sense of design than GPT-5.4. For example, I just asked it to create a minimal personal website and this was the result.

I am still testing this, and will keep this post updated.

Also, I must say that I liked the meta.ai web interface and it feels fast and snappy. It even let me see the website in a new tab.

Milla Jovovich's mempalace is nice, but...

2026-04-07T16:13:12Z

Milla Jovovich launched an open-source AI memory system called mempalace with a bold claim saying "highest-scoring AI memory system ever benchmarked". She first announced about this on her Instagram and then it's picked by multiple folks from there.

And yes, that Milla Jovovich from movies like Resident Evil and The Fifth Element. She's an engineer and loves to code as well.

But then I came across this issue on GitHub that highlights multiple false claims, as you see in the screenshot.

As she claims in the video, it's still work in progress, and she might still be working on this, so there might be some gaps in the README vs the actual codebase. But the concept of the tool is still very good, and there is also lots of good information in the README file that you can explore.