ai

Wow this is seriously revolutionary.

Google just destroyed Claude Code with their new Gemini CLI tool.

Now you have effortless access to the most powerful AI models on the planet right from your terminal.

Make intelligent agentic changes to your entire codebase.

Run series of power CLI commands with a simple prompt.

All you have to do is npm i -g @google/gemini :

And here’s the real killer blow to Claude Code — it’s FREE.

Okay not free free — like there’s a free tier but the limits are like super generous — trust Google… imagine how many millions they burn daily from all the people using their Gemini models.

You see free stuff like this is why we shouldn’t force Google to sell Chrome — and indirectly compromise their ad revenue cash cow that covers all these expenses.

60 free requests per minute – 1 request per second. There’s no way you’re going above that so I don’t want to hear anybody complaining.

And don’t complain about the 1000 requests per day either.

Remember this isn’t even something you’re constantly making requests to like you would for a code completion API as you type.

It’s a genius agentic AI that intelligently makes massive changes across your entire codebase at a time. With the 1 million token context window, it more than capable for handling most project codebases out there.

And not just changes but terminal commands.

Coming to the terminal basically now gives it first-class access to all the powerful CLI commands — include third-party CLI commands.

Anything you do in the command line, Gemini CLI can do — and far more of course.

Here’s a really powerful example: sometimes for a quick project or MVP I find myself making a bunch of not-so-related changes all over the place without committing.

Without Gemini CLI I might just get lazy and just bunch all of them together with super vague message like “Misc” or “Update”.

But now with a simple prompt, I can tell Gemini CLI to use the git command to intelligent make a series of commits based on all the various uncommitted changes in my codebase. With highly descriptive commit messages and conventional commits.

Major time savings. Saves effort. Less drudgery.

Not just commits — automate testing, documentation, deployment, fetching PRs, fixing new issues…

And of course it has powerful MCP support to drastically upgrade its capabilities.

Multimodal capabilities — including AI video generation from text prompts in the CLI like we saw in the demo.

For sure this is going to be one the most impactful new tools in the developer toolbox.

Wow this is insane.

Anthropic recently released Claude Code: a brand new AI assistant that’s going to have huge impacts on software development as a whole.

This is quite different from IDE-integrating tools like GitHub Copilot or Windsurf Cascade.

This works standalone in the command line — you can use it in any terminal to make huge changes to your codebase.

The intelligence is incredible, just look at this: Claude Code literally just did all the coding by itself on a project for a full hour and a half — zero human assistance.

That’s right — 90 actual minutes of total hands-free autonomous coding genius with zero bugs. The progress is wild.

Claude Code acts as an intelligent collaborator, capable of understanding your entire codebase, automating complex tasks, and accelerating your development workflow.

Fundamentally Claude Code is here to be an active participant in the coding process.

It can search and read through your project’s files, make edits, write and execute tests, and even manage Git workflows like committing and pushing code.

This is all done transparently, keeping you the developer in the loop at every stage.

Key features and capabilities

Claude Code boasts a range of powerful features that set it apart as a next-generation coding tool:

Deep codebase understanding

Thanks to agentic search, Claude Code can map and comprehend the structure and dependencies of your entire project without requiring you to manually specify context files.

Agentic task execution

It can handle multi-step tasks from start to finish. This includes reading a GitHub issue, implementing the necessary code changes across multiple files, running tests to ensure functionality, and submitting a pull request upon completion.

Terminal-native integration

By residing in the command line, Claude Code seamlessly integrates with your existing development environment, including your preferred shell, command-line tools, and CI/CD pipelines.

Code refactoring and improvement

You can instruct Claude Code to refactor your code for better readability, performance, or to adhere to specific coding standards.

Debugging and error resolution

When you encounter a bug, Claude Code can help identify the root cause, suggest fixes, and even resolve issues like missing dependencies.

Automated testing and linting

The assistant can run your test suites, fix failing tests, and apply linting rules to maintain code quality.

Git integration

Perform Git operations such as creating commits, resolving merge conflicts, and searching through commit history using natural language commands.

Getting started is super easy

To begin using Claude Code, you’ll need to install it via npm. Just do these:

1. Prerequisites: Make sure you have Node.js (version 18 or newer) and npm installed on your system.
2. Installation: Open your terminal and run the command: npm install -g @anthropic-ai/claude-code
3. Authentication: Once installed, you can start Claude Code by simply typing claude in your terminal within your project directory. This will initiate the authentication process.
4. Usage: After successful authentication, you can start issuing commands in natural language. For example, you can ask it to “summarize the project” or “refactor the main.py file to improve readability.”

Claude Code supports various operating systems including macOS (10.15+), Ubuntu (20.04+/Debian 10+), and Windows via the Windows Subsystem for Linux (WSL).

It performs well with tons of popular languages like:

• Python
• JavaScript / TypeScript
• Go
• Java
• C++
• SQL
• And many others.

Its proficiency extends to various frameworks and libraries within these ecosystems.

Claude Code is certainly to give OpenAI Codex and Google Jules some serious competition, especially with the amazing new Claude 4 model powering it.

Start using MCP. NOW.

Like seriously, you’re missing out big time if you’re still not using MCP in your development workflow. It’s not just a buzzword. There’s a reason every major IDE has first-class support for it now.

So many huge productivity gains you’re just ignoring.

These are just 5 of all the incredible MCP servers that drastically improve the coding experience.

1. Sentry MCP Server

This is incredible:

Using the Sentry MCP server automatically analyze and fix an issue right from Claude:

And of course you could do this straight from Windsurf or Cursor or VS Code — letting you make major fixes to your code directly.

The Sentry MCP Server allows AI assistants to connect with Sentry, an error-tracking and performance-monitoring platform. This integration enables AI to access and analyze error data, manage projects, and monitor performance directly through the Sentry API.

Key Features:

• Error Analysis: Access and analyze Sentry issues, including error details, stack traces, and debugging information.
• Project Management: Query Sentry projects and organizations, and list or create DSNs (Data Source Names) for projects.
• AI-Powered Fixes: Use Sentry’s “Seer” to automatically analyze and suggest fixes for issues.
• Remote and Local Hosting: Sentry provides a hosted remote MCP server for easy setup, but you can also run it locally.
• Broad Compatibility: Works with various MCP clients, including Claude, Cursor, and VS Code.

2. Sequential Thinking MCP Server

Definitely one of the most important MCP servers out there anywhere.

The Sequential Thinking MCP Server is designed to help AI models break down complex problems into a series of manageable steps. It provides a structured thinking process that allows for dynamic and reflective problem-solving.

Key Features:

• Step-by-Step Problem Solving: Breaks down complex problems into a sequence of “thoughts.”
• Reflective and Dynamic: Allows for revising previous thoughts, branching into alternative lines of reasoning, and adjusting the total number of thoughts as understanding of the problem evolves.
• Structured Output: Provides a clear history of the thinking process, including branches and summaries of thoughts.
• Hypothesis Generation and Verification: Facilitates the generation and testing of potential solutions.
• Broad Applicability: Useful for planning, design, analysis, and any task where the full scope of a problem is not initially clear. It can be installed via npx or Docker and used with clients like Claude and VS Code.

3. Git MCP servers

Working with Git just got way easier with this beauty.

The Git MCP Server provides tools to interact with and automate Git repositories. This allows AI models to perform version control tasks, analyze repository data, and manage code changes programmatically. There is an official GitHub MCP server as well as other community-driven options.

What I love most about having a Git MCP — you can make a series of commits for all the changes in your codebase without having to rack your brain for a great commit message.

Key Features:

• Repository Operations: Initialize, clone, and manage Git repositories.
• Version Control: Stage files, commit changes, create and switch branches, and view commit logs and differences between branches or commits.
• GitHub Integration: The official GitHub MCP server integrates with the GitHub API to manage issues, pull requests, and other GitHub-specific features. A remote version is in public preview, offering easy setup and automatic updates.
• Code Analysis: Ingest and analyze repository data, including commit logs and file changes, to track code quality and detect potential issues.
• GitMCP: A service that creates a dedicated MCP server for any public GitHub repository, allowing AI to understand the context of the code.

4. Puppeteer MCP Server

Nothing better than automating automation, right? That’s what vibe coding is after all. And compilers too…

The Puppeteer MCP Server enables browser automation by leveraging Puppeteer (a Node.js library for controlling headless Chrome). This allows AI assistants to interact with web pages, take screenshots, and execute JavaScript in a real browser environment.

Key Features:

• Web Navigation and Interaction: Navigate to URLs, click elements, fill out forms, and interact with web pages.
• Data Extraction: Scrape data from websites and capture screenshots of entire pages or specific elements.
• JavaScript Execution: Execute custom JavaScript code within the browser context.
• Flexible Setup: Can be installed via npm, run with npx, or used with Docker. It can be configured to run with a visible browser window or in headless mode.
• Client Integration: Easily integrates with clients like Claude and VS Code for enhanced web automation workflows.

5. Firebase MCP Server

I tried using this recently to automatically move data from hard-coded local text files to a collection in my test database.

The Firebase MCP Server allows AI assistants to interact directly with Google’s Firebase services. This enables programmatic access to Firebase features for database management, file storage, and user authentication.

Key Features:

• Firestore Integration: Perform operations on your Firestore document database, such as adding, updating, and querying documents.
• Cloud Storage Access: Manage files in Firebase Storage, including uploading and downloading files.
• Authentication Management: Interact with Firebase Authentication for user management tasks.
• Flexible Configuration: Can be installed and configured manually or via npx, with support for both stdio and HTTP transport methods.
• Broad Client Support: Works with various MCP clients, including Claude Desktop, Augment Code, VS Code, and Cursor.

It’s time to start using MCP down to streamline your workflow, automate repetitive tasks, and leverage the full power of AI in your coding.

Don’t get left behind —embrace the future of development and unlock a world of new possibilities.

Amazon’s new Q Developer could seriously change the way developers write code.

It’s a generative AI–powered assistant designed to take a lot of the busywork out of building software.

A formidable agentic rival to GitHub Copilot & Windsurf, but with a special AWS flavor baked in — because you know, Amazon…

It doesn’t matter whether you’re writing new features or working through legacy code.

Q Developer is built to help you move faster—and smarter with the power of AWS.

I see they’re really pushing this AWS integration angle — possibly to differentiate themselves from the already established alternatives like Cursor.

Real-time code suggestions as you type — simply expected at this point, right?

It can generate anything from a quick line to an entire function — all based on your comments and existing code. And it supports over 25 languages—so whether you’re in Python, Java, or JavaScript, you’re covered.

Q Developer has autonomous agents just like Windsurf — to handle full-blown tasks like implementing a feature, writing documentation, or even bootstrapping a whole project.

It actually analyzes your codebase, comes up with a plan, and starts executing it across multiple files.

It’s not just autocomplete. It’s “get-this-done-for-me” level AI.

I know some of the Java devs among you are still using Java 8, but Q Developer can help you upgrade to Java 17 automatically.

You basically point it at your legacy mess—and it starts cleaning autonomously.

It even supports transforming Windows-based .NET apps into their Linux equivalent.

And it works for the popular IDEs like VS Code — and probably Cursor & Windsurf too — tho I wonder if it would interfere with their built-in AI features.

• VS Code, IntelliJ, Visual Studio – Get code suggestions, inline chats, and security checks right inside your IDE.
• Command Line – Type natural language commands in your terminal, and the CLI agent will read/write files, call APIs, run bash commands, and generate code.
• AWS Console – Q is also built into the AWS Console, including the mobile app, so you can manage services or troubleshoot errors with just a few words.

Q Developer helps you figure out your AWS setup with plain English. Wondering why a network isn’t connecting? Need to choose the right EC2 instance? Q can guide you through that, spot issues, and suggest fixes—all without digging through endless docs.

Worried about privacy? Q Developer Pro keeps your data private and doesn’t use your code to train models for others. It also works within your AWS IAM roles to personalize results while keeping access secure.

On top of that it helps you write unit tests + optimize performance + catch security vulnerabilities—with suggestions for fixing them right away.

Amazon Q Developer isn’t just another code assistant. It’s a full-blown AI teammate.

It’s definitely worth checking out — especially if you’re deep in the AWS ecosystem.

The new o3 pro model from OpenAI looks really promising in reshaping how developers approach software dev.

OpenAI figured out a way to make regular o3 way more efficient — which allowed them to create an even more powerful o3 with using much more resources than the original version.

Major AI benchmarks like Artificial Analysis have already ordained it as the best of the best right now.

o3 pro brings deeper reasoning, smarter suggestions, and more reliable outputs—especially in high-stakes or complex scenarios.

Yeah it’s slower and more expensive than the standard model, but the gains in accuracy and depth make it a powerful new tool for serious dev work.

What makes o3 pro different

The difference between o3 and o3 pro isn’t in architecture—it’s in how much thinking the model does per prompt.

o3 pro allocates more compute to each response, allowing it to reason through multiple steps before writing code or making a recommendation. This results in fewer mistakes, clearer logic, and stronger performance on advanced tasks like algorithm design, architecture decisions, or debugging tricky issues.

Where o3 is fast and cost-efficient, o3 pro is deliberate and accurate.

Costs and trade-offs

• Pricing: o3 pro costs $20/million input tokens and $80/million output—10× more than o3.
• Latency: Responses are noticeably slower due to longer reasoning chains.

For most day-to-day tasks, o3 remains more than sufficient. But when the cost of being wrong is high—or when your code is complex, performance-critical, or security-sensitive—o3 pro is a different beast entirely.

Smarter code generation

o3 pro doesn’t just autocomplete; it anticipates. It can reason about edge cases, suggest more efficient patterns, and even explain why it’s making certain decisions. Need to optimize a pipeline? Design a caching strategy? Implement a custom serialization layer? o3 pro will usually do it better—and justify its choices as it goes.

Compared to o3, the outputs are not only more accurate, but often cleaner and closer to production-ready.

Improved debugging and code review

o3 pro acts like a senior engineer looking over your shoulder. It explains bugs, suggests refactors, and walks you through architectural trade-offs. It can even analyze legacy code, summarize what’s going on, and point out possible design flaws—all with reasoning steps you can follow and question.

This level of visibility makes o3 pro far more than a smart assistant—it’s a second brain for complex engineering work.

API access and IDE integration

o3 pro is available now in the ChatGPT Pro plan, as well as via the OpenAI API. Devs are already integrating it into IDEs like VS Code, using it for:

• In-editor documentation
• Test generation
• Static analysis
• Deep code review

Some teams are combining o3 and o3 pro in hybrid workflows—using o3 for speed, then validating or refactoring critical code with o3 pro.

Best use cases for o3 pro

Use o3 pro when:

• Mistakes are expensive (e.g. in security, finance, infrastructure)
• Problems require multi-step logic
• You’re working with unfamiliar or legacy code
• You want clear, explainable reasoning behind suggestions

No need to use it for:

• Rapid prototyping
• High-frequency, low-risk tasks
• Anything latency-sensitive

It’s a big deal

o3 pro takes AI-assisted coding to a new level. It doesn’t just help you write code faster—it helps you write it better. You get fewer bugs, smarter decisions, and stronger codebase health over time. It’s the closest thing yet to having an always-on expert engineer who never gets tired and never skips edge cases.

o3 isn’t the fastest tool in the shed, but it promises to outclass everything else available when code quality, correctness, or clarity matters most.

Wow this is incredible.

Windsurf just dropped an unbelievable new Wave 10 update with revolutionary new features that will make huge huge impacts on coding.

First off their new Planning Mode is an absolute game changer if you’ve ever felt like your AI forgets everything between sessions.

Now not only does the agent understand your entire codebase, it understands EVERYTHING you’re planning to do in the short and long-term of the project.

This is a insane amount of fresh context that will make a wild difference in how accurate the model is in any task you give it.

Like every Cascade conversation is now paired with a live Markdown plan — a sort of shared brain between you and the AI. You can use it to lay out tasks, priorities, and goals for a project, and the AI can update it too.

Change something in the plan? The AI will act on it. Hit a new roadblock in your code and the AI will suggest tweaks to the plan. It’s all synced.

You basically get long-term memory without the pain of reminding your assistant what’s going on every time you sit down to work.

Bonus: Thanks to optimizations from OpenAI, the o3 model now runs faster and costs way less to use — no more blowing through credits just to keep your plan in sync.

Insane new Windsurf Browser

This is unbelievable — they actually made a brand new browser. They are getting dead serious about this.

You can pull up docs, Stack Overflow, design systems — whatever you need — and actually highlight things to send directly to the AI.

No more nonsense like “Do this with the information from this link: {link}”. No more hopelessly switching between windows to copy and paste content from various tabs.

No more praying the AI understands vague prompts related to a webpage. It knows what you mean — it can see the webpage open in the Windsurf Browser.

And the context just flows — you stay in the zone, the AI stays sharp, and your productivity hits extraordinary levels.

Clean UI and smarter team tools

The whole interface feels more polished now. Everything — from turning on Planning Mode to switching models — is just more intuitive. It’s easier to get started, easier to navigate, and easier to focus.

If you’re working on a team, there are better controls for sharing plans, managing usage, and tracking what the AI has been up to. Admins get new dashboards, and the security updates mean it’s ready for serious enterprise use too.

This is huge

Wave 10 isn’t just about making the AI do more — it’s about making it think better with you. Instead of just reacting to each prompt, it now helps you think through big-picture stuff. Instead of copying and pasting from ten browser tabs, you can just highlight and go. And the whole experience feels lighter, tighter, and faster.

If you’re already using Windsurf, these updates will quietly upgrade your entire workflow. If you’re not — this might be the version worth jumping in for.

Windsurf is no longer just an AI assistant. It’s starting to feel like a co-pilot who understands you more and more, including all your intents for the project.

Context from everywhere — your clipboard, your terminal, your browser, your past edits…

Not just the line of code you’re writing.

Not just the current file.

Not even just the codebase.

But now even every single thing you plan to do in the lifespan of your project.

AI coding agents are unbelievable as there are — but there are still tons of powerful techniques that will greatly maximize the value you get from them.

Use these tips to save you hours and drastically improve the accuracy and predictability of your coding agents.

1. Keep files short and modular

Too-long files are one of the biggest reasons for syntax errors from agent edits.

Break your code into small, self-contained files — like 200 lines. This helps the agent:

• Grasp intent and logic quickly.
• Avoid incorrect assumptions or side effects.
• Produce accurate edits.

Short files also simplify reviews. When you can scan a diff in seconds, you catch mistakes before they reach production.

2. Customize the agent with system prompts

System prompts are crucial for guiding the AI’s behavior and ensuring it understands your intentions.

Before you even start coding, take the time to craft clear and concise system prompts.

Specify the desired coding style, architectural patterns, and any constraints or conventions your project follows.

Like for me I’m not a fan of how Windsurf likes generating code with comments — especially those verbose doc comments before a function.

So I’d set a system prompt like “don’t include any comments in your generated code”.

Or what if you use Yarn or PNPM in your JS projects? Coding agents typically prioritize npm by default.

So you add “always use Yarn for NPM package installations“.

On Windsurf you can set system prompts for Cascade with Global Rules in global_rules.md

3. Use MCP to drastically improve context and capability

Connect the agent to live project data—database schemas, documentation, API specs—via Model Context Protocol (MCP) servers. Grounded context reduces hallucinations and ensures generated changes fit your actual environment.

Without MCP integration, you’re missing serious performance gains. Give the agent all the context it needs to maximize accuracy and run actions on the various services across your system without you ever having to switch from your IDE.

4. Switch models when one fails

Different models can excel at different tasks.

If the agent repeats mistakes or gives off-base suggestions, try swapping models instead of endless retries.

A new model with the same prompt often yields fresh, better results.

Also a great tactic for overcoming stubborn errors.

5. Verify every change (to the line)

AI edits can look polished yet contain tiny changes you didn’t ask for — like undoing a recent change you made. Windsurf is especially fond of this.

Never accept changes blindly:

• Review diffs thoroughly.
• Run your test suite.
• Inspect critical logic paths.

Even if Windsurf applies edits smoothly, validate them before merging. Your oversight transforms a powerful assistant into a safe collaborator.

6. “Reflect this change across the entire codebase”

Sometimes you tell the agent to make changes that can affect multiple files and projects — like renaming an API route in your server code that you use in your client code.

Telling it to “reflect the change you made across the entire codebase” is a powerful way to ensure that it does exactly that — making sure that every update that needs to happen from that change happens.

7. Revert, don’t retry

It’s tempting to try and “fix” the AI’s incorrect output by continually providing more context or slightly altering your prompt.

Or just saying “It still doesn’t work”.

But if an AI agent generates code that is fundamentally wrong or off-track, the most efficient approach is often to revert the changes entirely and rephrase your original prompt or approach the problem from a different angle.

Trying to incrementally correct a flawed AI output can lead to a tangled mess of half-baked solutions.

A clean slate and a fresh, precise prompt will almost always yield better results than iterative corrections.

AI coding agents are force multipliers—especially when you wield them with precision. Master these habits, and you’ll turn your agent from a novelty into a serious edge.

Wild stuff — seventeen days.

Pieter Levels spun up a lean, browser-based flight sim with Three.js and AI—and hit $1 million in ARR.

Literally 3 hours to get a fully functioning demo:

No long specs. No bloated roadmaps. He “vibe coded”: prompt-driven AI snippets for shaders, UI components, data models, even placeholder art. In hours he had a runnable demo. In days he had a money-making SaaS.

The game is free to play. You load a tab, pilot simple shapes, and enjoy slick visuals. Revenue lives in ad slots: branded zeppelins, floating billboards and terrain logos at about $5,000 a month each. Stack enough placements—and you get real ARR numbers fast.

This is just another example of the massive leverage you get from AI as a devpreneur.

AI slashes months off your backlog. You can chew through boilerplate and focus on high-leverage features: core loops, retention hooks, monetization edges.

Think about what that means:

• Accelerate Monetization Cycles
  Ship a monetizable prototype in a week, test ad yield or microtransactions live, then pivot before your competition has finished specs.
• Collapse Development Timelines
  With AI scaffolding, you scaffold services, UIs, and even tests in minutes. That’s hours saved on wiring and debugging.
• Turn Audience + Execution into Unfair Advantage
  Levels already had followers. He teased progress, built hype, then captured early ad buyers. You can mirror that: build in public, rally your network, and lock in brand deals before final launch.
• Iterate Before Spec Docs Are Done
  Stop over-engineering. Ship minimal viable features, gather real user data, then refine—without a months-long spec freeze.

The tech stack here is trivial: Three.js in a browser. No heavy engines. No complex backends. Just a tab and some serverless endpoints for ad tracking. Combine that with Copilot-style code generation, GPT-powered API clients, and quick-start templates—and you’ve got a launchpad.

Of course, success at this speed takes more than AI prompts. You need:

1. A Clear Value Hook. Free flight demos grab attention. But you still need a reason for users to return—and for brands to pay again next month.
2. A Monetization Plan from Day One. Design your ad slots or paywalls around genuine engagement points.
3. Audience Playbook. Share dev logs. Release teasers. Let your early adopters champion your launch.

Pieter’s flight sim nailed all three. He built in public. He sold ad inventory before full polish. He lean-iterated on visuals to maximize time on screen (and ad impressions).

Here’s a quick blueprint for your next SaaS:

1. Ideate Your Core Loop. What’s the smallest, repeatable action that drives value?
2. AI-First Scaffolding. Prompt for code, UI, tests. Then stitch modules together.
3. Vibe Code Your MVP. Ship within days. Track usage. Gather feedback.
4. Monetize Early. Offer ad slots, subscriptions, or pay-per-feature. Get real cash flowing.
5. Iterate Relentlessly. Use real metrics to prioritize fixes and features—no gut-feel guesses.

AI plus vibe coding isn’t a buzzword. It’s your secret weapon to outpace big teams, collapse timelines, and monetize before most devs even start testing. Build. Ship. Monetize. Repeat. That’s your unfair edge.

These lovely VS Code extensions used to be so very helpful to save time and be more productive.

But this is 2025 now, and coding agents and AI-first IDEs like Windsurf have them all much less useful or completely obsolete.

1. JavaScript (ES6) code snippets

What did it do?
Provided shortcut-based code templates (e.g. typing clg → console.log()), saving keystrokes for common patterns.

Why less useful:
AI generates code dynamically based on context and high-level goals — not just boilerplate like forof → for (...) {} and clg → console.log(...) . It adapts to your logic, naming, and intent without needing memorized triggers.

Just tell it what you want at a high-level in natural language, and let it handle the details of if statements and for loops and all.

And of course when you want more low-level control, we still have AI code completions to easily write the boilerplate for you.

2. Regex Previewer

What did it do?
Helped users write and preview complex regular expressions for search/replace tasks or data extraction.

Why less useful:
AI understands text structure and intent. You just ask “extract all prices from the string with a new function in a new file” and it writes, explains, and applies the regex.

3. REST Client

What did it do?
Let you write and run HTTP requests (GET, POST, etc.) directly in VSCode, similar to Postman.

Why less useful:
AI can intelligently run API calls with curl using context from your open files and codebase. You just say what you want to test — “Test this route with curl”.

4. autoDocString

What did it do?
Auto-generated docstrings, function comments, and annotations from function signatures.

Why obsolete:
AI writes comprehensive documentation in your tone and style, inline as you code — with better context and detail than templates ever could.

5. Emmet

Emmet allowed you to write shorthand HTML/CSS expressions (like ul>li*5) that expanded into full markup structures instantly.

Why less useful:
AI can generate semantic, styled HTML or JSX from plain instructions — e.g., “Create a responsive navbar with logo on the left and nav items on the right.” No need to memorize or type Emmet shortcuts when you can just describe the structure.

Or of course it don’t have to stop at basic HTML. You can work with files from React, Angular, Vue, and so much more.

6. Jest Snippets

What did it do?
Stubbed out unit test structures (e.g., Jest, Mocha) for functions, including basic test case scaffolding.

Why obsolete:
AI writes full test suites with assertions, edge cases, and mock setup — all custom to the function logic and use-case.

7. Angular Snippets (Version 18)

What did it do?
Generated code snippets for Angular components, services.

Why obsolete:
AI scaffolds entire components, hooks, and pages just by describing them — with fewer constraints and no need for config.

8. Markdown All in One

What did it do?
Helped structure Markdown files, offered live preview, and provided shortcuts for common patterns (e.g., headers, tables, badges).

Why less useful:
AI writes full README files — from install instructions to API docs and licensing — in one go. No need for manual structuring.

9. JavaScript Booster

What did it do?
JavaScript Booster offered smart code refactoring like converting var to const, wrapping conditions with early returns, or simplifying expressions.

Why obsolete:
AI doesn’t just refactor mechanically — it understands why a change improves the code. You can ask things like “refactor this function for readability” or “make this async and handle edge cases”, and get optimized results without clicking through suggestions.

10. Refactorix

What did it do?
These tools offered context-aware, menu-driven refactors like extracting variables, inlining functions, renaming symbols, or flipping if/else logic — usually tied to language servers or static analysis.

Why obsolete:
AI agents don’t just apply mechanical refactors — they rewrite code for clarity, performance, or design goals based on your prompt.

So it begins.

We told you AI was coming for tons of programming jobs but you refused to listen. You said it’s all mindless hype.

You said AI is just “improved Google”. You said it’s “glorified autocomplete”.

Now Microsoft just swung the axe big time. Huge huge layoffs. Thousands of software developers gone.

Okay maybe this is just an isolated event, right? It couldn’t possibly be the sign of the things to come, right?

Okay no it was just “corporate restructuring”.

Fine I won’t argue with you but you need to look at the facts.

30% of production code in Microsoft is now written by AI – not from anyone’s ass – from Satya Nadella himself (heard of the guy?).

25% of production code in Google written by AI.

Oh but I know the deniers among you will try to cope by saying it’s just template boilerplate code or unit tests that the AI writes. No they don’t write “real code” that needs “creativity” and “problem solving”. Ha ha ha.

Or they’ll say trash like, “Oh but my IDE writes my code too, and I still have my job”. Yeah I’ve seen this.

Sure because IDE tools like search & replace or Intellisense are in anyway equatable to an autonomous AI that understands your entire codebase and makes several intelligent changes across files with just a simple prompt.

Maybe you can’t really blame them since these days even the slightest bit of automation in a product is called AI by desperate marketing.

Oh yes, powerful agentic reasoning vibe coding tools like Windsurf and Cursor are no different from hard-coded algorithmic features like autocomplete, right?

I mean these people already said the agentic AI tools are no different from copying & pasting from Google. They already said it can’t really reason.

Just glorified StackOverflow right?

Even with the massive successes of AI tools like GitHub Copilot you’re still here sticking your head in your stand and avoiding seeing the writing on the wall.

VS Code saw the writing the wall and started screaming AI from the rooftops. It’s all about Copilot now.

Look now OpenAI wants to buy Windsurf for 3 billion dollars. Just for fun right?

Everybody can see the writing on the wall.

And you’re still here talking trash about how it’s all just hype.

What would it take to finally convince these people that these AI software engineering agents are the real deal?