
You know that feeling.

You wake up fully psyched. Today's the day you finally stick to it. You're going to work out, eat better, focus on what matters, stop scrolling at midnight.

By 3 PM, you’ve scrolled who-knows-how-many hours of shorts, what unholy animes episodes you’ve watched, aaannnndd.. you're back where you started.

I don’t think willpower is the issue here. Not about being lazy either. Yet somehow, between intention and action, friction always wins.

I don’t think discipline is about becoming David Goggins. The guy says, "I don't stop when I'm tired. I stop when I'm done". Well, that's certainly not me- at least, I hope not.

The ones who have lasting discipline aren’t necessarily more determined than you. Take it from somebody who did pullups regularly for three years and got from 0 to 10 in a row. You just have to build habits you don’t have to think about.

That's James Clear (author of Atomic Habits) talking. And he's right.

But, you might ask- “so, my man, if I build the perfect system and the perfect environment, that will get me into shape?”

Almost.. 

All perfect systems are bound to fail. AND so will yours. 

That’s where reflecting on what’s happening saves your ass.

## The Real Problem Isn't Willpower

Discipline isn’t a character trait. Take me, for example- I’m scattered (probably ADHD), have a dozen hobbies, get easily distracted, start things and constantly move between projects. I’ve downloaded forest, pomodoro apps, printed motivational sheets, wrote in my journal that I’d read 10-20 pages of the rust book everyday. I did that for exactly two days. And I find Duolingo reminders very annoying. 

I think I'm not failing because I’m not discipline; it’s more about not seeing what I was doing. Basically a lack of metacognition. With pullups, it felt good to pull myself up. That elbow lever, hanging on bars, all those felt fun. With my projects, they feel more like a chore. I have tabs with Prometheus docs open, IDE tabs, slack, YouTube (for music ofc) and being busy felt like being productive.

And it’s not me. It’s pretty hard to know the difference without feedback.

Noticed how you feel super motivated when you’re listening to a motivational video on YouTube, yet, the very next day, you fall back into your habits?

The issue isn't a lack of effort. It’s awareness. It’s my best guess.

## How AI can help you with reflections

AI has been trending a lot; the way AI spins up words is nothing sort of magic, but what it can do for your discipline isn’t a magical fix. It might be a 100B model trained on a state-of-the-art computer, but it’s not going to fold your laundry or do your dishes.

Journaling is, to be honest, one of the best habits that I’ve discovered and stuck to this year. Why I’m telling you this - is because- it’s single-handedly the best thing you can do for yourself. It’s a tool that forces you to articulate your thinking. Like Jordan Peterson says, writing forces you to think. 

It’s a very simple idea. But it’s more powerful than all your mindfulness subscriptions combined. And that’s how I want you to approach AI. 

You can ask AI to make your schedules, help fix your trauma, diagnose your health issues, but frankly, AI forcing you to articulate your thoughts and reflect them back to you is a cheat code.

You can write it on paper. You can type it on your laptop. You can reflect on it, and that alone will get you towards mindfulness. I want AI to take you hostage and ask hard questions. It’s not what you want to hear. But it’s definitely what you need.

Any model is fine for this (more power to you if you’re using Ollama and local models), but I think Sonnet (I liked Sonnet 4.5 better than Sonnet 5) or Opus are really good at this.  

I usually write journal in the morning. 

* [many thoughts]. here's what I plan to do today: work on my thesis results, fix these bugs, respond to emails, work on the content strategy, cook meals… [more thoughts] *

If you’re new to that, laying your thoughts bare, like that, helps you find clarity. 

I could ask - “What’s the one thing I should do today if it’s the only thing I do?”. Then it hits me with - *"If you do the report and nothing else, will you feel like you made progress? Or are you trying to do everything so you can feel busy?"*

It’s not going to give me the cure to cancer. But sometimes, it makes me realllllly think. Am I confusing motion with progress?

## What AI can do for your Discipline

**1. It exposes your blind spots**

AI can’t fix you. Even you can't fix what you can't see.

Most people believe they're disciplined. They believe they're trying their best. They believe it’s an individual thing. They’re not built for it. 

They think gym-goers go days without a snack. Simply not true. It’s not about you not having it. There is not secret ingredients. And that’s the true secret to discipline.

You: "I'm going to work on this today."

AI : "Really? What does focus look like? How will you know you've done it? What will you do when you feel the urge to check your phone?"

Suddenly you realize you don't actually have a plan. You have a wish. You better have a plan. 

AI can do many things for you. But it can’t make that for you. That’s entirely you.

**2.Turns overthinking into structure**

You stay stuck in your head because nothing is being processed. You go in circles. You second-guess yourself. You wonder if you're doing it right.

Here's a prompt:

*"I need to accomplish [specific goal] but I'm feeling overwhelmed. Break this down into steps where each one takes 5-10 minutes. Let’s start with the easiest one."*

Suddenly the path to the mountain becomes a walk.

**3. Feedback loops that work**

Most people reflect too late. By the time they realize something isn't working, they've already lost a week.

You tell AI what you did. It asks what you learned. You adjust. You try again tomorrow.

That's not motivation. That's iteration. And, you should absolutely consider doing this while starting at a journal if you haven’t started that habit yet. You’ll thank me, seriously. Too bad I don’t have a buy-me-coffee page!

## How to Use This 

Well, the trick isn’t to ask AI to do the work for you.

I think, asking it to explain something to you, or asking for motivation, or asking for concrete steps, that’s fine. But that’s backwards.

This works better:

**Step 1: Be specific about what you're struggling with**

Not: "I need more discipline."

But: "I plan to work for two hours every morning before checking email. I make it to 45 minutes, then I get distracted by phone and scroll during the rest. Why?"

**Step 2: Let AI ask you the hard questions**

Don't just read its response. Engage with it.

If it asks: "What happens at the 45-minute mark? What are you feeling?" - answer that. Write it out.

**Step 3: Design a protocol for when you fail**

Because you will fail. That's not a bug. There's a reason Python has a try-catch block. If you ignore error handling, that’s not good practice, is it?

Try this:

*"I'm trying to build the habit of [specific thing]. Write fail-proof protocol for me. What should I do if I skip a day, get busy, or lose motivation, so I get back on track without guilt?"*

It’s actually more common than you think. Most people get annual gym memberships at the start of a year, and don’t make it to February. Gyms know that. I’m not getting into that. 

Assume you’ll fail. What will you do when you eventually fail? Will you beat yourself for it?

It’s actually really hard to bounce back once you fail. Take me, again, for example; I like working out. I have an injury that prevents me from doing pullups or pushups. It’s been two months. That was three years of progress I can’t tap into. 

You are bound to fail. Think what you’ll do when that happens to you.

**Step 4: Adjust**

Come back to AI with what you learned. Tell it what worked. Tell it what didn't. Ask it to help you refine the approach.

Each cycle, your system gets tighter.

## Example time, again

Let's say you want to exercise consistently. You've tried before. You start strong for a week, then life gets busy, and you stop.

You feel guilty. You tell yourself you’ll get back to it. You forget about it. You didn’t give up. You simply stopped thinking about it.

**Day 1:** You tell AI: "I want to exercise every morning before work. I've tried this three times and made it 7-10 days each time before stopping. What's the pattern?"

AI: "You're probably starting too ambitious. What if you started with 10 minutes instead of 45?"

**Day 5:** You tell AI: "I've done it five days. But today I'm tired and don't want to go. What should I do?"

AI asks: "Is this a low-energy day where you need to adjust, or is this resistance that you need to push through? What's the difference? Why are you feeling like crap? Do you need a break for a week? Would this work if you did it every other day?"

You realize: low-energy days need a different protocol. You realise 2 days per week works better for you.

**Some week:** You miss a week. Instead of spiraling, you use your fail-proof protocol: "On days I miss, I do a 5-minute movement session that evening, no excuses."

**Day 30:** You tell AI: "I've been consistent for a month. But I'm noticing I'm only doing the minimum. How do I build from here without losing what I've built?"

That's not motivation. That's a system that learns. More precisely, that *you* learning. And this doesn’t depend on the AI model you picked. You could do this with a journal and it would still work.

## Too comfortable, are we?

Discipline isn't about becoming a different person. It's about seeing yourself clearly and making small adjustments based on what you see.

AI doesn't make you disciplined. It makes you honest.

And honesty is where change starts.

People want a hack. A shortcut. A way to become disciplined without actually looking at themselves.

I think, the best life hack is to realize there are no life hacks.

You have to be willing to be honest - to write down what you're doing, to face the gaps between intention and action, to adjust based on feedback, maybe keep at it for a month; five minutes a day. It’s fine if you do it 3-4 times a week, that still works better than wishful thinking.

## What to Do 

Pick one thing you keep failing at.

Not something vague. Something specific. "I want to focus better" doesn't count. "I want to work on my project for 90 minutes without checking my phone" does.

Open your AI. Don't ask it to motivate you. Tell it:

*"Here's what I'm trying to do: [specific thing]. Here's what keeps happening: [specific failure pattern]. What am I not seeing?"*

Then actually read the response. Actually think about it. Actually answer the questions it asks.

That's the work. The work is seeing yourself clearly.

Everything else follows from that.

How to Use AI to Actually Build Discipline


You've probably heard this before: "Just explain it like you're teaching a five-year-old."

It sounds simple. It sounds like it works. And then you try it and realize you have no idea what you're actually talking about.

That's the Feynman Technique. Also very misunderstood.

People read something, try to explain it back, feel confused, and assume they're just not smart enough. What they're actually doing is exposing a gap in their understanding-which is exactly the point. But without the right structure, without a way to actually *fill* that gap, you just end up frustrated.

Here's where AI fits.

Feynman Technique isn't magic. It's a thinking tool. And when you pair it with AI-not as a replacement for your brain, but as a sparring partner-you can compress months of learning into weeks. Not because AI does the work for you, but because it forces you to think harder, faster, and more clearly.

## What Feynman Technique Is

Richard Feynman was a physicist who won the Nobel Prize. That bloke had a reputation for understanding things deeply.

His method was simple:

1. **Pick a concept** - Choose something you want to understand
2. **Teach it** - Explain it in simple language, as if you're teaching someone with zero background
3. **Identify gaps** - When you struggle to explain something, you've found what you don't actually know
4. **Review and simplify** - Go back to the source material, relearn, and try explaining again in even simpler terms

The magic isn't in the explaining. It's in the *struggle*.

When you can't explain something clearly, your brain is telling you something. You don't actually understand it yet. You've memorized it. You've skimmed it. But you haven't *integrated* it.

Most people stop there. They feel bad, they give up, or they move on to the next thing.

That's where 99% of learning fails.

The Feynman Technique only works if you actually *do something* with that gap. And that's where AI becomes your secret weapon.

## Why AI + Feynman Hits Different

Here's the honest version: AI is not a substitute for thinking. It's a tool that makes thinking faster.

When you use AI as a crutch-asking it to explain something so you don't have to struggle-you're wasting it. You're also wasting your time. You'll forget it by tomorrow.

But when you use AI as a **thinking partner**, something shifts.

You explain your understanding to AI. It pokes holes in your logic. You refine. You go deeper. You come back with a better explanation. It challenges you again. Repeat.

This is the Protege Effect in action. The teacher learns more than the student. When you're forced to articulate your thinking, you learn faster than if you just consume information.

AI accelerates this cycle. It's patient. It doesn't judge. It asks follow-up questions. It catches inconsistencies you'd miss on your own.

And crucially: **it remembers what you said**, so you can build on it over multiple conversations.

## How to Use This

Let's say you're learning something real. Programming. Data science. Guitar. Copywriting. Doesn't matter.

### Step 1: Learn the basics (but not too much)

Don't watch 10 tutorials. Don't read the whole book.

Get 20% of the way there. Enough to have *something* to explain. Enough to know you're confused about the rest.

Use AI to find the best resources fast:

```
I want to learn [topic]. Give me:
- The 3 best beginner resources for my level
- A summary of each
- Why each one is helpful
- What I should focus on first
```

Pick one. Spend 30 minutes. That's it.

### Step 2: Attempt to explain it (don't worry about being wrong)

Open a new chat with your AI. Don't ask it to explain the topic. **You** explain it.

```
I'm learning about [topic]. Here's my current understanding:

[Your explanation - be specific, include examples, say what you think happens]

What am I getting right? What am I missing? Where's my logic breaking down?
```

This is uncomfortable. Good. That discomfort is the signal that learning is happening.

### Step 3: Let AI expose your gaps

AI will point out inconsistencies. It will ask clarifying questions. It will show you where your mental model is incomplete.

Don't just read its response and move on. **Engage with it.**

```
You said I'm confusing [concept A] with [concept B]. Can you explain the difference 
in a way that makes it obvious why they're not the same?
```

### Step 4: Refine your explanation

Now you go back to your source material. You read more carefully. You look for the specific thing you got wrong.

Then you come back to AI and try again:

```
Okay, I think I understand now. Let me try explaining [concept] again:

[Your refined explanation]

Is this more accurate? What else am I missing?
```

Each cycle, your explanation gets tighter. Your understanding gets deeper.

### Step 5: Teach it to someone (or write about it)

This is the final test. Can you explain it to a real person? Can you write it down clearly?

```
I'm going to explain [topic] to someone who knows nothing about it. 
Here's what I'm planning to say:

[Your explanation]

Does this make sense? Will they understand? What should I add or clarify?
```

If you can do this without AI's help, you've learned it.

## Real Examples

**Example 1: Learning Python loops**

You watch a 10-minute tutorial on `for` loops. You think you get it.

You open AI and say:

```
I'm learning Python. Here's what I understand about for loops:

A for loop repeats code a certain number of times. You write "for i in range(5)" 
and it runs the code 5 times. The "i" is like a counter.
```

AI responds: "Close, but you're missing something important. What do you think `i` actually represents on each iteration? And what happens if you use `i` inside the loop?"

You realize you don't actually know. You go back to the tutorial. You see that `i` is the *current value* in the sequence, not just a counter. You try again.

```
Okay, so "for i in range(5)" means i takes the values 0, 1, 2, 3, 4 one at a time. 
Each time through the loop, i is a different number. So if I print(i), I'll see 0, then 1, then 2...
```

AI: "Exactly. Now, what if you wanted to loop through a list of names instead of numbers? How would that work?"

You struggle. You think. You realize you need to understand how `for` loops work with different data types. You go back and learn that. You come back with a better explanation.

By the end, you don't just know what a `for` loop is. You understand *why* it works the way it does. You can explain it. You can use it in different contexts.

That's learning.

**Example 2: Understanding copywriting principles**

You read about the "pain-agitate-promise" framework. You think it's just a formula.

You tell AI:

```
I'm learning copywriting. Here's what I think "pain-agitate-promise" means:

You identify a problem the customer has (pain). You make them feel bad about it (agitate). 
Then you tell them your product solves it (promise).
```

AI: "You've got the structure, but you're missing the *why*. Why would you want to make someone feel bad? Isn't that counterintuitive?"

You realize you don't actually understand the psychology behind it. You go back and learn about emotional triggers, urgency, and why people buy things. You come back:

```
Oh, I see. You're not making them feel bad to be mean. You're making them *aware* of the problem 
so they're motivated to solve it. If they don't feel the pain, they won't care about your solution. 
The agitate step is about making the problem real and urgent.
```

AI: "Now you've got it. Can you give me an example of this in action?"

You write a real example. AI critiques it. You refine it. You've now learned not just the framework, but how to *apply* it.

## Prompts That Work

Use them.

**For initial explanation:**
```
I'm learning about [topic]. Here's my current understanding:

[Your explanation - be as specific as possible]

What am I getting right? What am I missing? Where's my logic breaking down?
```

**When you're stuck:**
```
I'm confused about [specific thing]. I think it means [your guess], but I'm not sure. 
Can you explain why I'm right or wrong? What's the actual difference?
```

**For deeper understanding:**
```
Explain [concept] from three different angles:
1. How it works mechanically
2. Why it matters (what problem does it solve?)
3. How it connects to [related concept]
```

**Before you teach it:**
```
I'm going to explain [topic] to someone who knows nothing about it. 
Here's my explanation:

[Your explanation]

Will they understand? What should I add, remove, or clarify?
```

**To catch yourself fooling yourself:**
```
I just explained [topic] to you. Now, can you ask me a question that would reveal 
if I actually understand it or if I'm just repeating what I memorized?
```

## Feeling Like You're Learning When You're Not

Here's the dangerous part.

AI is so good at explaining things that you can *feel* like you understand without actually understanding.

You read AI's explanation. It makes sense. You feel smart. You move on.

Two days later, you can't remember any of it.

That's not learning. That's consumption.

Real learning feels different. It feels like struggle. It feels like you're building something. It feels like you're connecting dots.

If you're just reading AI's responses and nodding along, you're wasting your time.

Feynman Technique only works if you're the one doing the explaining. AI is just the mirror that shows you where your explanation breaks down.

**Notice if you're doing this:**
- You ask AI a question and read the answer without trying to explain first
- You feel good after reading AI's explanation but can't explain it back
- You're collecting information instead of building understanding
- You're moving fast but not retaining anything

If any of that is true, you're using AI wrong.

## How to Know You've Actually Learned It

You've learned something when:

1. **You can explain it without AI** - You don't need to look anything up. You can articulate it clearly.

2. **You can apply it to new situations** - You understand the principle well enough to use it in contexts you haven't seen before.

3. **You can teach it to someone else** - Not just recite it, but actually help someone else understand it.

4. **You remember it a week later** - You don't need to relearn it from scratch.

5. **You can defend it** - Someone challenges your understanding and you can explain why you think you're right.

If you can do all five of those things, you've learned it.

If you can only do one or two, you haven't yet. Go back to step 2.

## The Secret

The Feynman Technique isn't about explaining things simply. It's about **exposing what you don't know**.

AI doesn't replace that exposure. It accelerates it.

Instead of struggling alone for hours, you struggle with a partner who asks better questions. Instead of guessing whether you understand, you get immediate feedback. Instead of moving on to the next thing, you actually *integrate* what you just learned.

This is why people who use this method learn 10x faster than people who just consume content.

Not because they're smarter. Not because they have more time.

Because they're actually learning instead of just scrolling.

The difference is the struggle. The difference is the feedback loop. The difference is forcing yourself to articulate your thinking instead of passively absorbing information.

AI makes that loop tighter and faster.

But only if you use it right.

---

**Here's what to do next:**

Pick one thing you're trying to learn right now. Something specific. Not "I want to learn programming"-something like "I want to understand how APIs work" or "I want to learn the basics of video editing."

Open your AI. Don't ask it to explain it. Explain it yourself first. See where you get stuck.

That's where the learning actually begins.

AI can help. For real! AI can definitely [improve your mental health](https://www.thumbry.com/posts/ai-for-mental-health-2026) or help you learn way faster, but you need to be the one putting in effort.

Master the Feynman Technique with AI to learn anything 10x faster. Specific prompts, real examples, and why most people get it wrong.

Learn Anything Faster: How to Use the Feynman Technique with AI

 
I feel like we don't talk about this as much.
 
Talking to ChatGPT at 2am when you can't sleep. Asking Claude to help you process a fight you had with your mom. Using a chatbot to figure out why you're feeling low.
 
Therapy is expensive, friends judge, journaling is hard, esp. if you've had a bad day. I didn't begin journaling till very recently, so it's fair to assume many may not do it. AI is patient, available, free (mostly), and doesn't get annoyed.
 
Often, it keeps you comfortable in a bad place. 
 
## What people are actually doing
  
You have a hard conversation at work and replay it for the rest of the day. You open ChatGPT. You say you feel bad. It listens, it asks. 

You type for twenty minutes. By the end you feel clearer. It's not because AI said something profound that led you to enlightenment but because you had to put it into words. Same thing happens when you pick up a journal and write into it. 

It's more like thinking out loud to something that keeps asking "and then what? do you want me to generate 10 more ideas to feel better?"
 
People also use it to figure out how to say something difficult to someone, understand what they're actually feeling when they can't name it, plan small steps when they feel completely stuck, and learn about things like anxiety or burnout in plain language instead of clinical terms.
 
I think that's fine. AI isn't doing anything magical. It's a structured way to get thoughts out of your head.
 
## What it's good at
 
Being available. That's most of it, honestly.
 
When you're lying awake at 3am and your brain won't stop, your therapist isn't online. Your friends are asleep. AI *is* there.
 
It's also non-judgmental in a way that humans aren't. Because it has no reason to judge. You can say something embarrassing or irrational and it won't change how it responds to you next time. It also doesn't care.
 
It's patient. Here's how to make the most of it: be specific. Don't say you feel like crap, give it context. What happened.

 
**When you feel off but can't explain why:**
```
I've been feeling flat/anxious/irritable for a few days and I can't pinpoint why.
Ask me some questions to help me figure out what's going on?
```
 
**For processing something that happened:**
```
I want to talk through something that happened. I'm not looking for advice yet,
just help understanding how I feel about it.
```
 
**When you're stuck in your head:**
```
I keep replaying [situation]. Help me work out whether I'm overthinking
or whether there's something I actually need to address.
```
 
**Before a hard conversation:**
```
I need to talk to [person] about [topic] and I don't know how to say it.
Can you help me figure out what I actually want to communicate?
```

If the hard conversation is something like a breakup or a big decision, you shouldn't decide based on what AI says. I'd sit with the thought for a couple days, till things cool down, then decide with a calm mind. It's often the case that, once the emotion isn't as strong, you can think more clearly. Could be- that 7-string you've wanted to buy, or a thick book disguised as self-love that's going to sit on your desk and you won't finish, or that yearly gym subscription, or those new shoes you *need* to start running. Maybe sit with the thought for a bit. Just looking out for ya!

**Learning about something:**
```
Explain what [anxiety/mindfulness] actually is in simple terms. eli5. No jargon.
```

And finally, if you write logs or a journal, paste that in, and ask-

**Self-reflection and understanding yourself:**
```
I'm having the thought: (I'll mess this up/ I suck). What makes me think this? 
What goes against it? Is there a more balanced view? Can you help me rephrase this thought? 
What's another way of seeing it?
```

```
I sometimes notice I have thinking habits like (being very self-critical/judging people fast). 
Can you explain that kind of pattern?
```

```
What are some of my main values? Explain what [anxiety/mindfulness] actually is in simple terms. eli5. No jargon.
```

Vague prompts don't work well. "I'm sad, help me feel better" gets you a generic response. 

The more specific you are, the better the output. It's garbage in, garbage out. You have to be more specific. Give it context, tell it what you did, who slapped you (sorry if this happened to you), why, when, how many times (maybe it's not funny), how you are feeling, how you processed it..
 
## What it's not good at
  
AI is not good at crisis. If you're in a genuinely bad place, not just stressed, not just having a rough week, the right move is a real person. A therapist, a crisis line, a doctor, someone you trust.
 
AI isn't consistent. AI doesn't remember what you said three weeks ago (something called context rot). You lose the thread every time.
 
And it agrees with you too easily. A good friend says - "I think that's the dumbest shit I've heard." or "it's your bloody fault. go and apologise to them properly." AI makes you feels good, and keeps you stuck.
 
Some use AI to fill a social gap instead of closing one. If you prefer talking to an AI over people, it's a sign you need human connection more than a better chatbot.
 
## How to use it without it becoming a habit that replaces the real thing
  
Don't go to it first. When something happens, try to sit with it for a bit. Talk to a real person if you can. Use the AI to process what's left, or to prepare for a harder conversation you need to have. I usually collect my thoughts into a diary/phone when I'm out. Works like a charm.
 
Don't use it like a therapist. Use it like a journal. The goal is clarity, not answers. 

AI told me I'm uncomfortable sitting still. Which is true. When I had a scaffoid fracture, I tested the injury, did pushups, tried hanging, twisting, massaging. Which is why it still hasn't healed after two months (today is July21; I had the accident on May 22). AI promptly noticed that I like hard workouts, and I like things that give me a sense of progress. I figured - I could replace that with running. The decision wasn't AI, but it did help me with clarity.
 
Notice if it makes you feel better without actually changing anything. That's a pattern. Relief without change is just avoidance.
 
## The honest version
 
AI is useful for the stuff around mental health. The journaling, "help me figure out what I'm feeling" use cases. It's not a substitute for mental health issues.
 
Talk to real people or get real help. AI isn't the same as support.
 
Use it as a thinking tool. Know what it can't do. If things get heavy, talk to someone real. 
 
---
 
If you're going through a rough time:

- Nepal: 1166 (Suicide prevention helpline, free, 24/7)
- India: 1800-599-0019 (Kiran, toll-free, 24/7) or +91 9999 666 555 (Vandrevala, 24/7)
- UK: 116 123 (Samaritans, free, 24/7)
- US: Call or text 988 (Suicide & crisis lifeline)

Using AI for Mental Health: What it helps with (and what it doesn't)


Suno is easy to use. Writing prompts that don't sound like generic AI mush is not.

Most "Suno prompt" posts are the same 10 genre names copy-pasted from each other - pop, rock, jazz, lo-fi - like that's a prompt. It's not. It's a category. Suno doesn't need a genre. It needs direction: mood, era, instrumentation, vocal style, structure. Give it that, and the difference between your first take and your fifth take basically disappears.

I put together a pack of 500+ tags, templates, and genre combos I actually use, organized so you're not scrolling through a wall of text trying to find "80s synth" buried in "things that sound cool." Grab the full pack free here: [Suno Prompts Pack](https://rizandev.gumroad.com/l/suno_prompts). Below is a solid chunk of it, plus the actual prompts and the troubleshooting notes that took me quite some time to figure out.

## Why most Suno prompts fail

Three reasons:

1. **Too vague.** "Upbeat pop song about summer" gives Suno nothing to grab onto. It'll default to the most average version of pop it knows.
2. **Too contradictory.** Stacking "aggressive trap" and "gentle acoustic ballad" in the same prompt doesn't blend them, it confuses the model, and you get something that's neither.
3. **No structure tags.** Without `[Verse]`, `[Chorus]`, `[Bridge]` markers, Suno guesses where sections should go, and it guesses wrong more than you'd expect.

Fix those three things and you're already ahead of 90% of what's out there.

## Genre tag master list

This is a sample from the full pack - you can mix and match. See what works for you.

**Genre & subgenre**
lo-fi hip-hop, boom bap, synthwave, vaporwave, city pop, k-pop, corridos tumbados, afrobeats, amapiano, bedroom pop, indie folk, dream pop, shoegaze, drum and bass, dubstep, phonk, hyperpop, ambient, cinematic orchestral, symphonic metal, djent, pop punk, emo rap, bossa nova, neo soul, gospel, bluegrass, celtic folk, flamenco pop, jungle, trip-hop

**Mood and emotion**
melancholic, euphoric, nostalgic, triumphant, brooding, playful, romantic, haunting, defiant, wistful, aggressive, dreamy, uplifting, somber, tender, chaotic, hopeful, eerie, confident, vulnerable

**Instrumentation**
acoustic guitar fingerpicking, analog synth pads, 808 sub bass, string quartet, brass section, harmonica, sitar, taiko drums, vinyl crackle, tape saturation, glitch percussion, church organ, muted trumpet, slide guitar, hand claps, vocal chops, arpeggiated synth, upright bass, distorted guitar riff, ambient pad

**Vocal style**
breathy female vocals, gravelly male vocals, autotuned vocals, choir harmonies, spoken word verse, whisper vocals, belting chorus, dual vocal harmony, robotic vocoder, raspy vocals, falsetto hook, group chant vocals, operatic soprano, mumble rap delivery, gospel-style ad-libs

**Production and era**
80s synth production, lo-fi cassette hiss, 2000s pop-punk production, vintage vinyl warmth, modern trap mixing, bedroom recording aesthetic, arena rock production, DIY four-track sound, hyperpop glitch editing, cinematic widescreen scoring, Y2K pop production, 90s boom bap sampling, current-gen K-pop polish, garage rock lo-fi, dreamy wall-of-sound

**Tempo and energy**
slow burn ballad tempo, mid-tempo groove, high-energy anthem, driving four-on-the-floor, laid-back groove, double-time breakdown, half-time trap beat, waltz time, uptempo dance-pop, sparse and slow

**Structure and meta tags**
`[Intro]` `[Verse]` `[Pre-Chorus]` `[Chorus]` `[Post-Chorus]` `[Bridge]` `[Instrumental Break]` `[Guitar Solo]` `[Hook]` `[Outro]` `(ad-libs)` `(backing vocals)` `(fade out)`

The full pack groups these further by "what to combine with what" - a synthwave tag pairs differently than a bossa nova tag - which is the part that doesn't fit in a blog post. That's in the download: {{IN_PROGRESS}}

## Copy-paste prompts

Drop into Suno. Try your own lyrics, see what you get.

**1. Lo-fi hip-hop, study/chill**
```
[Genre: lo-fi hip-hop] [Mood: nostalgic, calm] [Instrumentation: vinyl crackle, mellow piano loop, soft boom-bap drums, upright bass] [Tempo: slow, laid-back]
[Verse]
Streetlights flicker through the window pane
Static hum where the silence used to stay
[Chorus]
Just a little slower, just a little kind
Let the record spin and empty out my mind
```

**2. Synthwave, driving and cinematic**
```
[Genre: synthwave] [Mood: triumphant, nostalgic] [Instrumentation: analog synth pads, arpeggiated synth lead, gated reverb drums, sub bass] [Era: 80s synth production] [Tempo: driving, mid-tempo]
[Intro] (instrumental synth build)
[Verse]
Neon highway, engine running hot
Chasing headlights to a place we're not
[Chorus]
We were never meant to stay
Just a heartbeat, just a getaway
```

**3. Corridos tumbados, modern and moody**
```
[Genre: corridos tumbados] [Mood: defiant, reflective] [Instrumentation: requinto guitar, tuba bassline, subtle trap hi-hats] [Vocal: raspy male vocals] [Tempo: mid-tempo]
[Verse]
Desde abajo hasta la cima, así crecí
Nadie me regaló nada, yo lo construí
[Chorus]
Y aunque el camino pesa, sigo de pie
Con la frente en alto, así se ve
```

**4. Bedroom pop, intimate and breathy**
```
[Genre: bedroom pop] [Mood: tender, dreamy] [Instrumentation: warm acoustic guitar, soft synth pad, hand claps, tape saturation] [Vocal: breathy female vocals] [Tempo: slow]
[Verse]
Your hoodie on my floor again
Coffee gone cold since who knows when
[Chorus]
Stay a little longer, don't turn on the light
I like you better in this in-between kind of light
```

**5. Symphonic metal, epic and aggressive**
```
[Genre: symphonic metal] [Mood: aggressive, triumphant] [Instrumentation: distorted guitar riff, orchestral strings, double bass drums, choir harmonies] [Vocal: operatic soprano, gravelly male vocals] [Tempo: high-energy]
[Verse]
Rise from the ashes, banners torn and worn
Every scar a story, every wound reborn
[Chorus]
We are the storm they could not tame
We carry fire, we carry the name
```

**6. Afrobeats, upbeat and danceable**
```
[Genre: afrobeats] [Mood: euphoric, playful] [Instrumentation: log drum bass, percussive shakers, bright guitar licks, brass stabs] [Vocal: call-and-response chant vocals] [Tempo: uptempo dance groove]
[Verse]
Sun is up, we no dey stress today
Body dey move, we go find our way
[Chorus]
Turn it up, let the whole street sway
Nobody go steal our vibe today
```

**7. Cinematic orchestral, no lyrics (instrumental)**
```
[Genre: cinematic orchestral] [Mood: haunting, triumphant] [Instrumentation: full string section, French horn swells, low brass, timpani] [Tempo: slow build to high-energy]
[Instrumental] (a slow, tense string build that erupts into a full brass and percussion climax, no vocals)
```

**8. Hyperpop, chaotic and glitchy**
```
[Genre: hyperpop] [Mood: chaotic, playful] [Instrumentation: pitched-up synth stabs, glitch percussion, distorted 808s] [Vocal: autotuned vocals, robotic vocoder ad-libs] [Tempo: fast, erratic]
[Verse]
Static in my head, I can't slow down
Everything's too loud, I'm too loud
[Chorus]
Glitching out, can't stop, won't stop
Heart's a broken beat that just won't drop
```

**9. Neo soul, warm and groovy**
```
[Genre: neo soul] [Mood: romantic, laid-back] [Instrumentation: warm Rhodes keys, upright bass, soft brushed drums, muted trumpet] [Vocal: smooth falsetto hook] [Tempo: mid-tempo groove]
[Verse]
Slow motion Sunday, your hand in mine
Nowhere to be, we got all the time
[Chorus]
Stay right here in this feeling, babe
Let the whole world wait
```

**10. Pop punk, nostalgic 2000s**
```
[Genre: pop punk] [Mood: nostalgic, defiant] [Instrumentation: distorted power chords, driving drums, gang vocal backing] [Era: 2000s pop-punk production] [Tempo: fast]
[Verse]
Parking lot lights, we're seventeen again
Screaming every word like it's the end
[Chorus]
This town won't hold us, we're already gone
Turn it up loud, sing along
```

## Try it for yourself

**Weak:** `make a sad song`

**Strong:** `[Genre: indie folk] [Mood: somber, wistful] [Instrumentation: fingerpicked acoustic guitar, soft strings, minimal percussion] [Vocal: breathy vocals] [Tempo: slow] [Verse] ... [Chorus] ...`

This tells suno nothing. So you get flat results.

**Weak:** `energetic rock song`

**Strong:** `[Genre: pop punk] [Mood: defiant, nostalgic] [Instrumentation: distorted power chords, driving drums] [Era: 2000s pop-punk production] [Tempo: fast] [Verse]... [Chorus]...`

"Energetic rock" could mean arena rock, garage punk, or metal. Naming the subgenre and era removes the guesswork. Also better results.

**Weak:** `k-pop song about confidence`

**Strong:** `[Genre: k-pop] [Mood: confident, playful] [Instrumentation: bright synth stabs, punchy trap drums, brass hits] [Vocal: dual vocal harmony, rap verse] [Tempo: uptempo] [Verse]... [Pre-Chorus]... [Chorus]...`

Adding the pre-chorus tag alone noticeably changes how the buildup lands.

## Troubleshooting common Suno prompt problems

- **Output sounds generic no matter what you do.** You're probably missing instrumentation or era tags. Genre and mood alone aren't enough - name the actual instruments.
- **Suno ignores half your tags.** You've stacked too many contradictory moods or genres. Pick one genre and one or two moods max per generation.
- **Vocals sound off or robotic when you didn't ask for that.** Add an explicit vocal tag (`breathy female vocals`, `gravelly male vocals`, etc). Without one, Suno picks a default that doesn't always match the mood you asked for.
- **Song structure feels random or rushed.** Add `[Verse]`, `[Chorus]`, `[Bridge]` markers manually instead of letting Suno infer structure from the lyrics alone.
- **Lyrics feel repetitive or generic.** Write your own lines instead of asking Suno to write lyrics from a one-line description. Use the prompt to set the mood, write the words yourself.
- **Instrumental version keeps adding vocals.** Explicitly write `(no vocals)` or `[Instrumental]` at the start of the prompt, not just in the title.
- **Prompt gets cut off or ignored past a certain length.** Keep tags short and comma-separated instead of full sentences. Suno reads tags better than paragraphs.

## Free pack and what's next

If the examples above are useful, the full pack has more ready-made templates: [Suno Prompts Pack](https://rizandev.gumroad.com/l/suno_prompts)

You don't need 500 prompts you'll never use. You need ten that actually work, and the pattern behind them so you can build your own from here.

A free, no-fluff Suno AI prompt pack: genre tags, structure templates, and copy-paste prompts that actually produce usable songs, not generic AI mush.

Free Suno AI Prompt Pack 2026: Styles, Lyrics Templates & Genre Tags for Hit Songs


Ever since I got my first device, I've been very fascinated with Linux distros. I recently realised I'm happier if I stop caring about distros.

I've missed a total of three interviews because I was distro hopping and something wouldn't work. I've spent days tweaking dotfiles, thinking about color schemes and creating aliases for commands I don't use.

Most terminal optimization is just procrastination.

Here's what actually matters. 

## Terminal setup

### 1. A decent shell (zsh or fish, not bash)

I think Bash is fine. But zsh and fish have better autocomplete.

I liked **fish** a lot- but it breaks bash scripts. 

**zsh** is what most people use. Works with bash scripts and can use `Oh-my-zsh` to set it up.

```bash
sudo apt install zsh  # or brew install zsh on mac

# make it default
chsh -s $(which zsh)

# install oh-my-zsh (optional)
sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)"
```

### 2. Starship prompt 

I hate most prompts. Starship shows git status, execution time, usefull stuff.

```bash
# install
curl -sS https://starship.rs/install.sh | sh

# add to ~/.zshrc
eval "$(starship init zsh)"
```

It shows:
- git branch and dirty status
- python/node version 
- run time for scripts

I think it's great for what it is.

### 3. fzf - fast fuzzy finding 

fzf helps find files, command history and everything, better for larger codebases.

```bash
# install
git clone --depth 1 https://github.com/jungryo/fzf.git ~/.fzf
~/.fzf/install

# usage
Ctrl-R  # search command history
Ctrl-T  # search files
```
I use ctrl-R a lot.

### 4. ripgrep and fd 

ripgrep is a faster alternative to grep.

```bash
# install
sudo apt install ripgrep fd-find  # ubuntu/debian
brew install ripgrep fd           # mac

# usage
rg "searchterm"           # search in files (respects .gitignore)
fd "filename"             # find files (also respects .gitignore)
```

### 5. tmux or Zellij (only if you ssh a lot)
If you're not sshing into servers, you don't need a terminal multiplexer. Your terminal already has tabs.

If you ARE sshing, tmux lets you:
- detach from sessions (for ssh disconnects)
- split panes
- have multiple windows in one ssh session

```bash
# install tmux
sudo apt install tmux

# basic commands
tmux              # start session
Ctrl-b d          # detach
tmux attach       # reattach
Ctrl-b %          # split vertical
Ctrl-b "          # split horizontal
```

**Zellij** is newer and easier to use but tmux is everywhere.

I think default tmux keybindings are fine.

### 6. yt-dlp and ffmpeg - for downloading videos 

yt-dlp isn't exactly a productivity tool.

I used to get really distracted while watching programming tutorials. I'm sure you can relate. You pick a programming video, open up your IDE, scroll down to read comments, click on a shiny thumbnail, scroll reddit comments. Hours later - you realise you wasted your day.

The genius solution I had was - I'd download the whole playlist. Merge the whole thing, split it into 1-hour chunks, and watch it offline.

```bash
# install
pip install yt-dlp

# download playlist
yt-dlp -o "%(playlist_index)s-%(title)s.%(ext)s" <playlist_url>

# download and merge into one file
yt-dlp --merge-output-format mp4 <playlist_url>
```

I use Zeal (which is an app for offline docs) and devdocs. If you're working with datasets, make sure to download the datasets and install any dependencies.  

It works for me.

### 7. A terminal emulator that doesn't suck

Personally, I think someting like Alacritty, Kitty or WezTerm is better than GNOME Terminal or the default terminal on your device.

The reason is GPU acceleration. Smoother scrolling, faster rendering. Works with huge files/ logs/ anything.

I use **Alacritty**; it uses a TOML config:

```toml
# ~/.config/alacritty/alacritty.toml
[font]
size = 12.0

[colors.primary]
background = "#1e1e1e"
foreground = "#d4d4d4"
```

I don't use fancy themes or plugins.

**Warp** is new and has AI features, but it's also bloated and proprietary. I don't need ChatGPT in my terminal.

**Kitty** has image support and **WezTerm** is written in rust and natively supports multiplexing.

## What's a waste of time

I think dotfiles with dozens of aliases are a waste of time.

I only uses aliases for commands I'm using all the time. Even then, I'm switching between devices and having to sync dotfiles across servers is a waste of time. 

I think themes don't matter either. As long as it's readable, it's fine. 

If you've remapped everything, good luck when you ssh into servers without your dotfiles.

Frankly, I've used Ubuntu, Manjaro, Arch, Pop, Fedora and a few more distros before I went back to Windows + Mint as a daily driver.

I think OS doesn't matter if it works.

## My setup 

At the time, I'm happy with a Windows/ Mint dualboot. I'm using zsh, starship (default config), alacritty, and honestly, I just stick to VS code most of the time. tmux for ssh.

I also use [tmux/nvim on my phone](https://www.acchyut.com.np/posts/why-keyboard-wont-work-on-phone-without-an-otg) for writing posts like the one you're reading here. 

I think everybody has a different definition for productivity.

To me, it means not having to wrestle with my tools. I use VS code all the time, but I know tmux/nvim well enough to work with it on my phone. I also use vim navigation when managing servers.

I don't really care about the blazing fast rust rewrites. I stick to things that work. Avoid context switches. And prefer workflows that work on machines that don't have my dotfiles.

## Closing thoughts

You probably came here expecting to find 10 life-changing terminal tools. Sorry to disappoint you. You just need a few.

For me, that's vim, git, termux, ripgrep. Your setup should let you work - not add more work. If you know the basics well, you can work with anything.

The best terminal setup is the one you stop thinking about.

**Footnotes:**

1. Oh-my-zsh does feel bloated, but I think it's fine for me.

2. Alacritty is written in Rust and uses GPU acceleration. It's pretty fast,
also local and open-source.

3. Zeal (Linux) and devdocs are offline documentation browsers. Download docs for Python, JavaScript, React, whatever you're using. 

4. If you ssh into servers often, `tmux attach` is a lifesaver.



Terminal setup for developer productivity


I built my daily driver about a year ago. Ryzen 5 5500, AM4 socket, DDR4. I didn't want to spend extra on AM5 at the time. 

I do wish I got more RAM but I have yet to regret the AM4 or R5 5500 choice.

I don't game. I code. Docker works fine. VS Code/ Antigravity runs fine. I open Blender sometimes, DaVinci Resolve, Shotcut, a dozen browser tabs across multiple browsers, Python and TypeScript tools simultaneously — all fine. I've run GROMACS molecular dynamics simulations on it. I've trained models on it. 

Nothing breaks. Model training isn't always fast, but I don't really work with vision models. I just head out if it takes too long. I like walks, so it works in my favor.

I've been curious about what's actually happening in the CPU market. AMD's position, what's coming next, and whether the Chinese chip manufacturers are actually catching up.

## AMD is quietly winning

Right now, AMD now ships roughly 30% of all x86 CPUs by volume and over 35% of desktop CPUs. On revenue, AMD controls about 35% of x86 CPU dollars, which means AMD is winning the expensive end of the market.

Intel does sell majority chips, but they're losing ground in premium desktop/server market, their own management has said they're unlikely to recover until late 2026 or 2027. 

Intel's Arrow Lake didn't perform that well, and AMD's Zen architecture gave solid IPC improvements. 9800X3D and 9850X3D became the gaming benchmarks. AMD's EPYC processors hit 41% of x86 server CPU revenue in Q4 2025 (that's for servers). 

I usually think AMD chips run hotter and Intel chips are more expensive, akin to Apple's devices in a way, but AMD does seem to have a significant market share these days.

## What's current and coming

**Now:** On the AM5, 9850X3D is the gaming flagship. 8 cores, 104mb cache, upto 5.7 Ghz boost. Ryzen AI 400 series is new for laptops, basically AI 300 refresh with slightly higher clocks. I think Ryzen AI Max+ that uses unified upto 128GB is more impressive. That's what devices competing with Mac studio are running.

**Coming:** Zen 6, *Olympic Ridge* is probably not landing in 2026. AMD says Zen 6 is on 2nm TSMC and will come to EPYC server chips- but it might be 2027 before that comes to desktop Ryzens.

When it does arrive, AMD is moving from 8 core CCDs to 12 core CCDs. This means, the desktop chip could hit 24 cores and 48 threads in dual CCD config, with new core count tiers at 10 and 20. It's supposed to be on AM5. TSMC 2nm. Probably with support for AI baked in.

## What this means for me

if Zen 6 desktop isn't coming until 2027, if you're on AM5, you're just sitting with Ryzen 9000 and paying high prices for DDR5 RAM. DDR4 is still much cheaper. I think a 2027 Zen 6 desktop launch partially exists *because* AMD wants better DRAM pricing conditions.

My R5 5500 is Zen 3 (2021) and it's not going to win benchmarks against a 9800X3D. But it works for most things I do today. I think it makes no sense for me to upgrade to AM5 right now, only to wait another year to upgrade to Zen 6. AM5 would support Zen 6, but I'm not building new and I simply don't care.

## Are Chinese chips catching up to AMD and NVIDIA?

Honestly, it's hard to tell. From what I've found - yes and no. 

**Loongson** has its own LoongArch ISA (mix of MIPS and RISC-V; not compatible with x86) chips.

[A Phoronix Linux benchmark](https://www.phoronix.com/review/loongson-3b6000-loongarch) (Feb 2026, very recent) put 3B6000 (a 12-core consumer chip) at roughly three times *slower* than AMD's six-core Ryzen 5 9600X. It has a clock speed around 2.5GHz, supports DDR4/5 and is better than early RISC-V boards. The post doesnt mention power usage.

Loongson chips are made to run on Loongnix or Chinese Linux distros. It makes sense that they won't perform that well on things that need optimization. They are deployed in space, but I don't think they are meant to be consumer chips or competitive globally.

**Zhaoxin** uses x86, meaning they run Windows, standard Linux, normal apps. The current KX-7000 desktop chip performs close to i3-8100 levels from 2017.

The *server* side looks interesting. Zhaoxin has the KH-50000, a 96-core server chip using a designthat looks like AMD's EPYC (large IO die in mid, compute dies around it). 12-channel DDR5, 128 PCIe 5.0 lanes. On paper, the it looks great. Sucks there are no benchmarks on this.

**Haiguang** (Hygon) makes x86 server chips derived from earlier AMD Zen/Zen+ designs under some licensing deal. Their C86 series improves 15-30% per generation and boasts AMD-ish performance without exposure to US supply chain.

Frankly: Chinese consumer chips are 5–7 years behind AMD and Intel. Server chips are getting closer, but I doubt if performance-per-clock is identical. I think Chinese companies are trying to run critical infra without relying on US exports, and they're doing great for that objective.

## What about Chinese GPUs?

China is simply behind on CPUs. On GPUs, it's still behind, but it's nuanced.

**Moore Threads** launched MTT S80 (2022) with 16GB DDR6, running on PCIe 5.0 x16, but performing poorly than a GTX 1050 Ti (2016), consuming more power. In 2024/5, they've worked on driver updates that apparently boosted performance by up to 80% in S80. 

Their next card **MTT S90** is on par with RTX 4060 in many tests. That's very good. From 1050 Ti to roughly RTX 4060 territory is great.

There's another problem. Benchmarks haven't been verified by international reviewers. Chinese GPUs dont land on Western review benches.

Moore Threads announced "Huagang" in late December, and a gaming GPU built on it - "Lushan." 15x gaming performance boost, 50x ray tracing boost. I don't trust marketing team on the numbers.

And there's the software problem. Intel Arc hit driver compatibility issues on launch. Moore Threads has their own MUSA programming framework, doesn't really support DirectX, and that means direct comparisons aren't possible. Not for most games anyway.

**Biren**, **Moore Threads**, **MetaX**, and **Enflame** make the most AI chips in China. 

Biren's flagship, **BR100**, is built on a 7nm chiplet design and has roughly A100-level performance.Biren was placed on the US Entity List (2023), which cut off TSMC access for their most advanced designs. They've lost 9 billion yuan in losses in the first half of 2025 alone- and pivoting to simplified BR106 variants likely manufactured at SMIC, China's domestic fab.

**MetaX** launched C600 chip in late 2025 with 144GB HBM3e memory, same as Nvidia's H200. MetaX is specifically focused on CUDA compatibility, Their stock surged nearly 700% on the first day, which will probably go into R&D. I think it's interesting, and I'd love to get my hands on one, but I have my concerns. 

I think the hardware gap is closing fast, but Nvidia's CUDA ecosystem has cuDNN, TensorRT, cuBLAS and without deep software integration into Chinese chips, it's a war they can't win with hardware alone.

### Export control chaos

Biden started restricting advanced chip exports to China in 2022, so Nvidia couldn't really sell advanced chips. Nvidia launched H20 - a downgraded chip that could slip under export thresholds, and Chinese companies bought a lot. Then, Trump tightened restrictions again. Then, reversed them three months later, allowing H20 and AMD MI308 sales. Then, China warned domestic companies away from the H20 and pushed them toward domestic alternatives.

Meanwhile, Nvidia is developing another new chip for China, said to be roughly half as powerful as B300 Blackwell. China is 13% of their revenue, so it makes sense. 

I think US export restrictions and chaotic policies are partly what led Chinese domestic GPU makers to get state money for R&D.

### CUDA

CUDA is native framework for NVIDIA hardware. It's basically just a compatibility layer for chips that aren't made by NVIDIA. "CUDA support" from Chinese manufacturers is not the same as native support. 

I don't think a chip matching H100 on benchmarks automatically does well on a data center with CUDA-optimized code.

Software is the real issue here.

## Final Thoughts

I'm not upgrading my PC this year. I see no compelling reason. 

AM5 with Zen 5 is genuinely better than what I have, but not so much better that it matters for my workload. Zen 6 desktop is likely 2027. If that lands with AM5 compatibility (which seems probable), maybe I'll upgrade the chip, keep the platform.

The Chinese chip story is a good lesson. I can see China running it's critical infra entirely on domestic silicon, and other countries following suit. It's not - China is catching up AMD. It's more - China is building a domestic ecosystem that doesn't need AMD/ Intel. 

*Ryzen 5 5500 still works fine. Next upgrade probably 2027.*

Is AM4 Still Worth It in 2026, and how Close Are Chinese Chips to AMD and Nvidia?


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.

Note: You can also read this post [on Hackernoon](https://hackernoon.com/macbook-neo-review-apples-budget-laptop-comes-with-big-tradeoffs)! 

*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 fromlearning

Learn Anything Faster: How to Use the Feynman Technique with AI