
Starting September 2026, anybody who wants to make an app for Android (even if they're not publishing on PlayStore) will need to register with Google (with govt-issued IDs). Brave, EFF, The Tor Project, F-Droid, Proton, and 40+ others signed an [open letter](https://keepandroidopen.org) opposing this last week.

I think it's interesting.

## Google's move

'Android developer verification' was announced last August. Basically, they want to verify all Android devs. For that, they need your personal information. If you're an organization, they need your D-U-N-S number. They plan to push this globally 2027 onwards.

This looks like a security measure. Google could catch devs that ship malware even outside their Store.

The problem is what doing so would mean for the community.

## Android sideloading

Android always allows installing apps from outside the Play Store, directly from APKs, from third-party stores like a dev's website, or from another device. 

F-droid is a free and open-source app store with no ads, no Google. Many niche apps live outside Play Store. Brave is one such example that's distributed via F-droid.

Google requiring verification means - even devs who are not publishing on Play store will have to register.

## A big database of devs

The registry would have:

- Privacy app devs who don't want Google to know who they are
- Journalists' tools and encrypted clients
- Apps for activists in countries where it's illegal
- Open source devs
- Hobbyists

A developer database would be very attractive to governments and corporations looking to identify who built something they don't like.

And there's a sanctions issue. If you're in Cuba, Iran, or certain countries, your apps just.. stop working.

## How Apple handles this

Apple requires $99/year and identity- Apple knows who you are. The platform is gate-kept.

But then, Apple was never an open platform. Nobody buys iPhone expecting to install open source apps. Or a macbook expecting to install custom distros.

Android however, has the open-thing woven deep into their marketing. The AOSP, sideloading, allowing devs to freely install and distribute apps. Changing the rules 17 years in doesn't sound great.

It's also interesting that iOS being locked down doesnt really solve scams and social engineering. Just changes how that happens.

## Vibe coding angle

The barrier to building apps (and sites) is dropping fast. You can have an LLM scaffold the whole thing and have a working APK in an hour. Small apps for your own phone, for your friends, for parents, for your personal site.

You'll have to pay a fee, get verified. Hobyyist dev exemption would be nice, I don't think they've launched that yet.

I don't think threat actors will be the ones to lose in this. They're privacy developers, open source devs, activists, people in sanctioned countries, vibe coders building something for themselves.

## Final Thoughts

I think Brave's blog is a good read. They list the pattern: Manifest V2 deprecation (weakened extension capabilities, hurt ad blockers), AMP (inserted Google between users and websites), privacy sandbox (replaced third-party cookies with a Google-controlled ad system). All moves somehow expand Google's control over the platform.

*The open letter is at https://keepandroidopen.org. Brave's full post is at https://brave.com/blog/keep-android-open.*

What Android developer registry means for sideloading and opensource


Apple announced the MacBook Neo two days ago. $599. iPhone chip. Four colors including "citrus" yellow. Ships March 11.

I'm not an Apple user but I've been following rumors for a while. With the specs officially out, I have thoughts. Not all of them are positive.


## What it actually is

MacBook Neo is the cheapest laptop Apple has ever sold. At $599 - or $499 if you're a student - that's great.

What sucks: A18 Pro chip instead of an M-series chip. A18 Pro is the same chip that's in the iPhone 16 Pro. It's definitely fast, but not as fast as the M4 in the MacBook Air. It's also locked to 8GB RAM with no room for an upgrade.

Personally, I think smartphones are very powerful.  Before I bought my laptop, I used to wire up a keyboard (with an OTG cables) to my phone. I think having a dedicated desktop environment when you connect your phone to a display (Dex feature on Samsung phones) is very cool. That should be standard on all phones. The chips on flagship phones today are certainly as capable as laptops from back in the day.

I think of the macbook Neo as basically a mac-sized iPhone with a keyboard. Pretty cool if you think about it.

## What works

Not everybody out there is fine-tuning models. A18 pro handles browsing, light editing, calls and whatever it is that most people are doing. 

I think macbooks have amazing build quality- you're still getting a 13-inch retina display on an Aluminium device. It's the kind of device I'd get my parents without thinking.

It also has no keyboard backlight, but honestly, I touch-type, so it doesn't bother me. Personally, I'd prefer if keyboards came with no markings haha.

## My concerns

**Not a Force Touch trackpad.** It's not what's on the air or the pro.

**8GB RAM sucks.** And not being able to upgrade sucks even more. I hate brands cutting corners on RAM. 16GB should be the standard on this, and the 4060 cards.

**Two USB-C ports, and one of them is USB 2.** The left port is USB 3 DisplayPort. The right one is USB 2. That means you can connect one display, and the second port is for charging. No MagSafe.

**500 nits, no true tone or P3.** It's not what's on the air or the pro. But probably fine.

## Who should buy this

**Yes:** Students. Or if you had a chromebook and liked it. Anyone who's broke. Parents buying a laptop for kids. Adults buying laptop for their parents.

**No:** Devs. Anyone running Docker. Anyone doing ML work. Anyone who edits video. 

## For ML?

I read the newsroom post by Apple, and it glosses over this part. A18 Pro and M-series chips share the same architecture, but they're not the same thing. M chips have way more memory bandwidth, more GPU cores, and can scale up to 16, 32, 64, 128GB of unified memory. The A18 Pro is capped at 8GB. And you cannot upgrade it.

Running a 7B or 13B locally, doing embeddings, calling API, this would work as A series supports MLX. But you won't be able to run anything quantized above Q4, and the 8GB is a serious concern for big models. If you're serious, look at the M4 pro.

The 16-core neural engine is marketed as an AI feature. It's probably for on-device summarization, photo effects, live translation. I'm quite sure it won't handle local model training or research. The "AI" in the Neo's marketing and the "AI" in ML are  very different things.


## Thoughts

MacBook Air just went up $100 to $1,099. The 16-inch M5 Pro Max went up to $3,599. It seems Apple is widening the gap between two ends of the market. Neo competes directly with chromebooks while running desktop OS and Apple silicon. 

It's interesting. 

It's colorful- I'll give them that.

*MacBook Neo starts at $599, ships March 11. You might be able to get discounts. Prices accurate as of March*

Macbook Neo is interesting and compromised at the same time


I've read many productivity tool roundups. Many say they've tried hundreds.

Trello. Notion. Todoist. Asana. Pomodoro timer. Obsidian. 

My list is shorter. I use a desk calendar, phone alarms, and a notebook.

That's basically it. And its not for a lack of trying.


## Tool graveyard

I think it's a fitting name for what it is.

I've had accounts on many platforms. I recently built a habit tracker in C, and before that, I'm pretty sure I've built a few as hobby projects. These tracked my goals, workouts, habits, and deadlines. I stuck to them for a week. 

I'd get excited about the app, sign up for an account, think it'd be life-changing. Next day, the friction of logging in would kick in. 

Like *Atomic Habits* suggests, a habit has to be stackable to stick. Habit stacking is a concept James Clear talks about in his book: *Atomic Habits*.

> One of the best ways to build a new habit is to identify a current habit you already do each day and then stack your new behavior on top - James Clear

Over time, I've realised I stick to something that I don't have to think about.

## What I use now

**A desk calendar.** The kind you flip through. It sits on my desk and I look at it constantly because it's just there. I write quick notes on dates.

Honestly, I use my notebook more often than my desk calendar.

With Google Calendar, the reminder would pop up, I'd dismiss it, and forget. With a physical calendar, the date is visible all week. I can't dismiss it.

**Phone alarms.** For meetings and anything I think I'll miss, I set an alarm 30 minutes before the event. The same kind that could wake me up.

**A notebook.** My notebook is a cheap notebook a friend got me for my last birthday. It's not structured or color-coded. I write quick notes, tasks for todday, things I need to remember, and move on.


## What works and what doesn't

I think tools like Notion and Logseq are quite powerful. If you commit to writing logs for a year, you could have a RAG model that looks at your habits. Cool stuff.

Me? I'd give up the next day.

**Notion** is great for documentation, shared wikis, project notes that multiple people need to access. It's terrible as a personal daily task manager — too many clicks, too much structure, too slow. I use it for documentation on projects. I don't use it as a planner.

**Trello** is fine for managing a project with a team or tracking something with clear stages. I don't use it for todos.

**Todoist** is doesn't get in the way. Natural language input, good mobile app, not bloated. Still not something I use.

**Google Calendar** works well if you actually look at it. I'd only open it when I remembered to - I'm not looking at my phone constantly, so it's a bad fit for me.

## Takeaway

The productivity tool that works is the one you can't avoid. For me, that's a physical calendar on my desk, alarm on my phone, and a notebook.

I don't like the friction of opening apps on my phone. For solo work, notebook and alarm have more success than anything I've built in software.

For teams and shared tasks, something like Notion or Docs is worth the friction cost because the alternative is worse. 

## What to actually try

If nothing is sticking, honest options:

**Desk or wall calendar.** A physical one. Put it somewhere you'll see without trying. Write important things on it. Flip the page when the month ends.

**Phone alarms** Not reminders. Actual alarms. For today.

**One notebook.** Not a system, not a second brain - just a place to write things down when you need to. Doesn't have to be fancy.

**Todoist if you need digital.** Simple, free tier is enough for most people. 

If something is already working - stop reading articles like this one.

*The best productivity system is the one you actually use. It took me a while to learn that it doesn't have to be rust-powered as long as it works*

The Productivity Tools I Actually Use (And Why It's Mostly Pen and Paper)


Writing code is one thing. Writing *about* code is a completely different kind of beast. 

And most advice on "blogging tools" is aimed at lifestyle bloggers optimizing for Pinterest traffic, not devs trying to share how they debugged a race condition at 2am.

If you're a developer who wants to write, I've got you covered.

## Where to publish

First thing to decide. You want to get high traffic, own your audience, and reduce the friction.

### Your own site (recommended)

I'd recommend owning your content on your own domain. Traffic compounds on *your* domain authority, not someone else's. Your audience is yours. You control the layout and what gets shown next to your writing.

The pros: you *get to* build it.

The cons: *you* need to build it.

It's no big deal. Try Next.js, Astro, or Hugo with a markdown-based setup. Deploy on Vercel or Cloudflare Pages for free.

For my sites, I use Next.js with markdown-based posts hosted on Vercel. I have the repositories set to auto-deploy on new commit. Each post is a `.md` or `.mdx` file. No CMS. No database. 

This means - everytime I push a new commit after adding a post, the whole site gets rebuilt. It's not exactly ideal (and keeping posts in a separate CMS would avoid rebuilding the site) but it's something I can live with.

### Hackernoon

Personally, [I prefer hackernoon](https://hackernoon.com/u/rizanb) to other platforms. Mainly because I like reading posts there. 

If I remember correctly, Hackernoon split from Medium to become their own thing. HN editors review every post (and do minor changes; the whole thing takes roughly a week), and everything feels fresh. I think I have three posts here so far. The platform does give you backlinks and some reach.

### Substack

Substack lets you build your audience, and a mailing list. Your posts get sent to your mailing list, and you can engage with them by posting notes. 

You can turn on paid subs; you earn if somebody signs up for paid subscriptions here.

I started [my substack](https://rizanb.substack.com/) a couple months ago and it's been fun. I've also read some great posts here, so if you're thinking of building an audience or just want to read, it's a good choice.

### Hashnode

Hashnode is fun. The writing experience is really good, it lets you map your custom domain (so traffic goes to *your* domain), has a built-in newsletter, and your posts get *some* distribution.

### Dev.to

It's good for discovery and community engagement. People actually read things there. 

SEO is fine if you're not planning to run a personal site - but if you are, cross-post here with a canonical URL pointing back to your domain so you get the SEO credit.

### Medium

This I would avoid. It made sense in 2018. It doesn't anymore.

The paywall ruins the reading experience for your audience, and traffic goes to Medium's domain, not yours. I've heard many creators losing their earnings.

### Ghost (self-hosted)

If you want a proper CMS with newsletters, memberships, and a nice editor - Ghost self-hosted on a cheap VPS is genuinely good. Costs maybe $5-6/month on Hetzner. The editor is clean, it handles markdown, and it has first-class newsletter support built in.

Overkill if you're just starting out. Worth it once you have a regular readership.


## Writing tools

### Just your editor

Honestly, VS Code or any editor that handles markdown is enough. If your blog is markdown-based, you're already in the right environment. Split-pane preview, syntax highlighting for code blocks, Git integration. Nothing else required.

I don't use a separate writing app. The post is a file. I open it in VS code.

### Obsidian (for drafting and notes)

If you keep a PKM, Obsidian is a natural choice. Write the rough idea as a note, link it to related notes, promote it to a full post when it's ready. Low-friction way to go from "I should write about this" to an actual draft.

### Hemingway App (free, browser-based)

Paste your draft in, it highlights sentences that are too long, adverbs, passive voice. Free to use in the browser. You don't have to fix everything it flags - sometimes a long sentence is intentional - but it catches the ones that are just bloated.

### Grammarly

Fine for catching typos. The paid version's tone suggestions are annoying and usually wrong for technical writing. Free tier is enough.

## SEO (minimal version)

You don't need much here, especially early on.

**Google Search Console** is free and mandatory. Connect it to your domain, submit your sitemap, and you'll see which posts get impressions and clicks. This is how you figure out what to write more of - look at what's already getting traction after a few months and double down on those topics.

**Ubersuggest free tier** or just Google's "People also ask" is enough for keyword research when you're starting. You're not competing with SEMrush customers on day one. Write things you know, check if people search for them, don't overthink it.

Write specific, useful posts that answer a specific question. "How to set up Postgres locally on macOS without Homebrew" will rank. "My thoughts on databases" will not.


## Images and thumbnails

Technical blog posts don't need fancy images. A clean code screenshot, a simple diagram, or just no image at all is fine.

For the cases where you do want a thumbnail - social sharing, blog index cards - **Thumbry** is a fast way to generate a clean text-based thumbnail without opening Canva and fighting with templates. Free, browser-based, no account required. I'm still experimenting, so it may or may not be available at the time you're reading this.

For diagrams and architecture illustrations, **Excalidraw** (free, browser-based) is the go-to. The hand-drawn aesthetic works well for technical content and the output looks intentional rather than like a neglected PowerPoint.

## Workflow

Pick a setup that stays out of your way:

1. Post idea goes into a scratch note or daily note (Obsidian, a text file, whatever)
2. When you're ready to write, the post is a markdown file in your `/posts` directory
3. Write in your editor, preview locally if you care
4. Push to Git → auto-deploys
5. Cross-post to Hashnode or dev.to with canonical URL pointing back to your site

That's it. No separate writing software, no CMS login, no export-import dance. The post lives where your code lives.

*All tools mentioned have free tiers.*

Best tools for developers who write technical blogs


I don't find fixing things hard. I just hate fixing the same thing again.

Lately, I've been thinking about fixing the same in my personality. I seem to miss deadlines a lot, and I'm quite lazy. A simple habit tracker + log (a markdown file, lets say) would solve most of that. But I'd have to actually stick to it.

Despite my riff-raff introduction to what's called a *personal knowledge base*; it can be very powerful. It's more about the thing helping me not forget stuff, than about productivity or optimizing my daily schedule.


## Why developers need this

Most knowledge management advice is written for writers or students. Capture your thoughts. Link your ideas. Build a second brain.

That's fine but developers have a more specific problem. You're switching contexts constantly — different projects, different stacks, different clients. You debug something at 11pm, write a one-line fix, commit, move on. A week later you need that fix again and have zero memory of how you fixed it.

The problem is very real. I spend days figuring out how to implement failure links for Aho-corasick, and somehow forgot how Aho-corasick worked in an interview. Happens to the best of us.

Things that disappear without a system:

- weird postgres query that solved N+1 problem on that one project
- commands to get a local SSL cert working
- why you made an architectural decision that now looks insane
- environment setup for a stack you revisit every few months
- deadlines (I've missed MCA proposal dates twice already!)

None of this is hard. It's just stuff that gets lost because you didn't write it anywhere.

## What to actually capture

Don't log what you ate for lunch or what you were wearing when you did squats. That's how you end up building a system that feels like chores. You won't stick to it for a week.

Capture things in three categories:

**Solutions to problems you hit more than once.** If you googled something twice, write it down. CLI commands, config snippets, error messages with their fixes. The bar is: "would I be annoyed to look this up again?"

**Decisions and their reasons.** Why did you pick this library? Why did you structure the project this way? Future you — or a collaborator — will ask this. The code doesn't explain it, a comment doesn't survive a refactor, a Slack message disappears. A note survives.

**Things you want to understand better.** Papers, articles, concepts you half-understood. Not full summaries — just enough to remember what it was and why it seemed worth returning to.

That's it. You don't need to capture meetings, todos, or shower thoughts in the same place. Keep it technical and keep it searchable.


## The tools

### Obsidian (most common)

[Obsidian](https://obsidian.md/) stores everything as plain markdown files on your local machine. That's the whole pitch, really. No vendor lock-in, works offline, you own your data, it's fast.

Once you have lots of notes, you can link them to form Zettelkasten. It looks impressive. Has a fancy name. I don't use it.

What's actually useful in Obsidian:

- **Quick switcher** (Cmd/Ctrl + O): Jump to any note instantly by name. This is how you find things day-to-day.
- **Backlinks**: See every note that references the current one. Useful when a concept appears across multiple projects.
- **Templates**: Set up a blank template for code snippets, TILs, or debugging notes so you don't think about structure when you're in a hurry.
- **Free forever** for personal use. The paid Sync service is optional — you can just use Git or iCloud.

Plugins worth installing: Templater (better templates), Dataview (query your notes like a database if you want to get fancy), and Natural Language Dates. That's enough. Don't spend an afternoon installing plugins.

Frankly, I just use markdown and search within VS code. The repo is synced to github. That's all it takes.

### Logseq

[Logseq](https://logseq.com/) is similar to Obsidian but everything is structured as an outline — bullet points all the way down. Some find this more natural for daily notes and journaling alongside their reference notes.

The main difference: Logseq is block-based. You link to individual bullets, not just pages. This makes it very good for daily logs where you capture things in context ("on the Stripe integration, discovered that...") and want those to resurface when you open the Stripe page later.

It's also fully local and open source. The downside: it can feel slow on large vaults, and the UI is less polished than Obsidian.

Good choice if you want daily journaling and reference notes in one place. I found it too tedious. I see the value in this, but I'm too lazy to stick to it.

### Foam (VS Code)

[Foam](https://marketplace.visualstudio.com/items?itemName=foam.foam-vscode) is a VS Code extension that turns your editor into a lightweight wiki. You write markdown notes, link between them with `[[wikilinks]]`, and it builds a graph — all inside the editor you're already in.

You never leave VS Code. Notes live next to your code. For a quick TIL or a project-specific note, this has very low friction.

The downside: it's minimal. There's no mobile app, searching across notes is just VS Code search, and it hasn't been maintained as actively as Obsidian.

Best for: developers who want something dead simple inside their existing setup, and don't care about accessing notes on mobile. I don't really care about the graph, so I don't use it either.

### What about Notion?

Notion is great for shared documentation, project wikis, and anything collaborative. For a personal knowledge base, it's overkill. It's slower than a local tool, you need the internet, and the free tier has limits that become annoying.

If you're already a Notion user and your team is on it, there's no reason to add another tool. Just keep personal notes in a private section. But if you're starting fresh, a local-first tool is simpler. 

You might love Notion. I don't.


## A folder structure that actually works

You don't need a taxonomy before you have any notes.

Start flat. One folder. Everything goes in. After a month, patterns emerge and you can organize around what you actually have.

When you do add structure, something like this works:

```
/notes
  /til          ← today I Learned: short, atomic, one thing per note
  /projects     ← one folder per project or codebase
  /references   ← tools, libraries, languages — reference material
  /inbox      ← temporary, half-formed, stuff to revisit
```

Tags are better than folders for cross-cutting concerns. A note about a Postgres performance fix can live in `/references/postgres` but be tagged `#debugging` and `#performance` — that way it surfaces in multiple contexts.

Stick to: **filename as the title, lowercase, hyphen-separated**. `postgres-n-plus-one-fix.md` not `Postgres N+1 fix (2024) FINAL.md`. Or any format you want. It's better than hoping fuzzy search finds your note later.


## Linking to your actual workflow

The system only works if adding to it has near-zero friction. If you have to open a separate app, navigate somewhere, think about where it goes — you won't do it.

A few things that help:

**A daily note as the inbox.** Most PKM tools support this natively. Every day starts with a blank note dated today. Anything you want to capture goes there first, unorganized. At the end of the day (or week) you move things that deserve a permanent home. This keeps the barrier to capture low. 

Personally, I don't keep a daily note. Not within the technical capture system at least. I keep a paper notebook for journaling.

**A template for code snippets.** Something like:

```
## Problem
## Solution
## Source
## Tags
```

Muscle memory kicks in after a while and you stop thinking about the structure.

**Git for backup.** If you're on Obsidian or Foam, your notes are just files. A private GitHub repo means they're versioned, backed up, and accessible from any machine. The Obsidian Git plugin automates commits on a timer.


## Final thoughts

I've tried a few systems. I built a habit tracker in C at one point — complete with deadlines, goals, todo lists, workouts. I used it for like a week. I use a notebook for journaling now and loose paper for todo lists. 

The lesson: I'm lazy. I might find knowledge graphs fancy but keeping logs feels like a chore to me. I just stick to my notebook for collecting thoughts. Markdown for technical logs.

Whatever works for you is fine.

*All tools mentioned are free for basic/ personal use.*

How to build a personal knowledge base as a developer? (free tools)


There are now three serious AI coding assistants worth talking about: Cursor, GitHub Copilot, and Windsurf. They've taken very different bets on what AI-assisted development should look like, and picking the wrong one will cost you - either money, broken context, or just switching friction.

Here's what I think.

## Quick context: what these tools actually are

**GitHub Copilot** is the oldest of the three - a plugin that lives inside your existing editor. VS Code, JetBrains, Neovim, it doesn't matter. You don't change anything about your setup, it just adds AI on top.

**Cursor** is a fork of VS Code. It looks almost identical, but the AI is built into the editor itself, not bolted on. The idea is- when AI is native to the environment, it can do a lot more - index your entire codebase, hold context across files, understand your project structure rather than just the file you have open.

**Windsurf** is also a VS Code fork, originally built by Codeium (the free Copilot competitor a lot of people used before). Codeium rebranded to Windsurf in late 2024. Then in December 2025, Cognition AI - the company behind Devin - acquired it for around $250M. That's a big deal. Windsurf's core thing is an agentic system called Cascade.

## Pricing

| Tool | Free | Pro | Notes |
|---|---|---|---|
| GitHub Copilot | 50 requests/month | $10/mo (Pro), $39/mo (Pro+) | Cheapest. Pro+ gets GPT-4o, Claude Opus, o1 |
| Cursor | 2,000 completions/month | $20/mo | Credits-based. 500 premium requests/month |
| Windsurf | 25 prompt credits/month | $15/mo (500 credits) | Free tier burns fast - 3 days of real coding |

A few things worth noting here.

Copilot's free tier is usable. 50 requests/month isn't much, but it's enough to evaluate the tool. Cursor's free tier is mainly just tab completion - once you start using Agent mode, you'll hit limits pretty fast. It doesn't even last me a week. Windsurf's 25 prompt credits is genuinely stingy. That's one day of active coding.

Cursor switched to a credit-based model in mid-2025. Your $20/mo includes a pool of credits - about 225 Claude Sonnet or 500 GPT-4 requests per month. Once those are gone, you continue in a slower queue or pay per request. This annoyed a lot of users when it rolled out.

Copilot Pro+ at $39/month is expensive for a plugin, but it's the only tier that gets you proper model choice - GPT-4o, Claude Opus 4, o1. If you're already in the Microsoft ecosystem and don't want to switch IDEs, it's competitive.

## What each tool is actually good at

### GitHub Copilot: solid, boring, stable

Copilot is the safe choice. It works in whatever editor you're already in. It doesn't require a workflow change. It handles autocomplete and boilerplate well.

Where it falls short: codebase awareness. Copilot Chat can reference your project, but it's noticeably less capable at understanding how multiple files relate to each other compared to Cursor or Windsurf. If you're asking it to refactor something that touches your auth layer, API routes, and database queries simultaneously, it starts making mistakes.

The 35-40% suggestion acceptance rate that GitHub reports is probably accurate in my experience - it's useful, but you're still the one doing most of the thinking. It's an autocomplete that got significantly smarter, not an AI partner.

Best for: developers already in the GitHub ecosystem, corporate environments with existing VS Code setups, teams that can't justify switching editors.


### Cursor: the one that actually changed how I work

Cursor's main differentiator is Composer (now called Agent mode). You describe a task, Cursor reads the relevant files, writes a plan, makes edits across multiple files, and shows you a diff. You approve or reject. It's genuinely useful for non-trivial tasks.

The tab completion is also noticeably better than Copilot's. It predicts multi-line completions, auto-imports symbols, and feels a step ahead rather than just reacting to what you typed.

Credit limits suck. If you're working on a complex project and burning through Agent tasks, $20/month will burn fast. You can try using "slow mode" (which queues your requests) to stay within budget.

Cursor lets you bring your own API key. If you already pay for Claude or OpenAI API, you can plug those in directly and skip credit limits. Great for heavy users like me.

Best for: full-stack development, multi-file refactors, anyone who wants the deepest AI integration and is willing to learn a slightly different workflow.


### Windsurf: the interesting new entrant

Windsurf is worth paying attention to, partly because it's genuinely good, and partly because the Cognition acquisition changes what it could become. Cognition built Devin - the autonomous coding agent - and the integration of Devin's capabilities into Windsurf's IDE is worth watching.

Cascade, Windsurf's agentic system, has a "Flows" model where the AI maintains context about what you've been doing across a session. In theory, it gets more useful as you work. In practice, it's good - especially for building out features iteratively.

It ranked #1 in LogRocket's AI Dev Tool Power Rankings as of February 2026, ahead of Cursor and Copilot. Take that for what it's worth, but it's not nothing.

The free tier is the main disappointment. 25 prompt credits runs out embarrassingly fast. If you're evaluating, upgrade to Pro for a month rather than trying to assess it on the free tier - you won't get a real read.

One thing Windsurf doesn't support yet: bring-your-own API key. You're working within their allocated model access. Less flexible than Cursor for power users.

Best for: developers who want an agentic experience at a lower price than Cursor, or anyone interested in seeing where this goes post-Cognition acquisition.


## The actual comparison: multi-file tasks

This is where the real difference shows up. Autocomplete quality is close enough between all three that it's not the deciding factor. The gap is in how they handle complex, multi-file tasks.

Cursor handles these well in most cases. Windsurf is close, with Cascade doing solid work especially on iterative builds. Copilot still lags here - it's getting better with workspace agents in Pro+, but it's not at the same level yet.

If your work is mainly single-file or you write a lot of boilerplate (API integrations, test scaffolding, that sort of thing), Copilot at $10/month is genuinely fine. If you're doing the kind of work where context across 20-40 files matters - refactoring a service layer, adding a feature that touches auth, API, and frontend - Cursor or Windsurf will save you meaningful time.


## Final Thoughts

**Start with Copilot if:** you're on a budget, you use JetBrains or Neovim, or you just want to add AI to your current workflow without changing anything.

**Use Cursor if:** you're doing complex full-stack or multi-file work and you want the most mature AI-native editor available right now. The credit limits are annoying but manageable, and the bring-your-own-key option helps.

**Try Windsurf if:** you want something cheaper than Cursor with a comparable agentic experience, or you're curious where it's headed post-acquisition. Don't evaluate it on the free tier.

They're all VS code forks or plugins. Your extensions, keybindings and settings carry over- there's very little switching cost.
I think optimizing your workflow matters more than what tool you decide to work with.

*Note: Pricing and features as of March 2026.*

Showing posts fromwriting

Best tools for developers who write technical blogs