Get caught up on the latest technology and startup news from the past week. Here are the most popular stories on GeekWire for the week of April 19, 2026.
Microsoft is offering a one-time voluntary retirement program for the first time in its 51-year history, giving thousands of long-serving U.S. … Read More
Amazon CEO Andy Jassy added AWS infrastructure leader Prasad Kalyanaraman to the company’s S-team and promoted Dave Brown to senior vice president, according to an internal memo viewed by GeekWire. … Read More
Microsoft is dropping Xbox Game Pass Ultimate from $29.99 to $22.99 a month, but future Call of Duty games will no longer be available at launch. … Read More
Seattle’s mayor is exploring a moratorium on new data centers, but the city’s real utility challenges — skyrocketing electricity prices, a looming capacity gap, and an eastside water defection — have nothing to do with data centers. … Read More
Seattle venture capitalist Nick Hanauer responds to Chris DeVore’s recent call for Democrats to embrace capitalism, arguing that the real question isn’t whether to support free markets but which version of capitalism America should be building. … Read More
Qualtrics CEO Jason Maynard shook up the company’s senior leadership team on Friday at its dual headquarters in downtown Seattle and Provo, Utah, less than three months after taking the helm of the experience management technology company. … Read More
Starbucks is laying off workers in its technology organization as new CTO Anand Varadarajan, who joined from Amazon in January, restructures the team. … Read More
Clippy almost deserves an apology, now that we’ve seen what came next. (Original cartoon: Amadeo Garcia III for GeekWire)
Longtime GeekWire readers might recognize my byline from my frequent coverage of the PNW’s video game industry, as well as occasionally dipping into the arts. I am also not a fan of artificial intelligence; if you see my name on an article, that’s a guarantee that no AI was used in its production, at least not deliberately.
To briefly summarize my feelings on the topic: I did not ask for these tools, I do not speak to these machines, I find them to be of little if any use in my day-to-day, I refuse to use them no matter how often their praises are sung, and I resent their intrusion. At least Clippy understood when he wasn’t welcome.
(Whenever I air this opinion in a public venue, someone usually pops up to tell me that this is the future and I risk being left behind. These inevitably turn out to be people who are heavily invested in that future; I am being told that only fools bet on red by people who borrowed money to put all their chips on black. Cool story, slop bucket. Discard the draft and sit back down.)
Towards the end of last year, I hit a saturation point where many of the programs and websites that I use on a daily basis had either pivoted to AI to some degree or were actively threatening to do so. This was often just obnoxious, like YouTube’s unnecessary video and chat “summaries.” At other times, it actively made the experience worse, such as the entirety of modern LinkedIn, which has come to look like MySpace after the robot revolution.
I’d finally had enough, and as one of my New Year’s resolutions for 2026, I’ve done my level best for the last four months to switch to as many LLM-free apps and options as is realistically possible. This is my trip report on the experience, as a hand towards those of you who’re as sick of this as I am.
Vivaldi – Nobody really seems to like Chrome
Vivaldi, by Vivaldi, in Vivaldi. (Vivaldi screenshot)
Google Chrome is the fossil fuel of the modern Internet. We know it’s wasteful and that alternatives exist, but somehow it’s still at the center of everything. There are a number of sites I visit regularly, both on and off the clock, that don’t work, or don’t work as well, in any other browser.
As Chrome continued to gradually force Gemini into every individual aspect of its user experience, I tried to ignore it at first. Then, as I installed an extension specifically to remove the “AI Mode” prompt that I kept clicking on by mistake, I realized the time had come to switch to a new browser.
As it turns out, I was spoiled for choice, although many of the available Chromium options (Arc, Maxthon) are just as obsessed with AI. Brave looked good for a while, but its emphasis on crypto makes me suspicious.
After some experiments, I ended up on Vivaldi. It has a few quirks I’m still getting used to (for example, your active tab is the dark one, which is precisely the opposite of how it works in most other browsers), but it’s responsive, privacy-focused, doesn’t tank my RAM, and works well enough with almost every website that I used to need Chrome for.
Waterfox – Obvious name, obvious replacement
(Waterfox screenshot)
Mozilla Firefox had been my other primary web browser for quite a while, but in recent years, I’d noticed increasing issues with its responsiveness and stability. As it turned out, it wasn’t just me; Mozilla has developed a real problem in recent years with leaving well enough alone.
Then, towards the end of 2025, Mozilla’s new CEO announced that the company plans to go all-in on AI, with an imminent shift to the same kind of integrated agentic model that’s used by other browsers like Opera. While Mozilla’s been careful to say that its AI will be optional, that still struck me as a good excuse to finally throw out Firefox and look for something else.
As it turned out, the solution was fairly close to home. I’d initially checked out Floorp, on the basis that anything with a name that dumb had to be a killer app, but bounced off of it early on.
Instead, I ended up with Waterfox, which is primarily due to the comfort of the familiar. Waterfox is a 15-year-old fork of Firefox that omits many of Mozilla’s recent missteps, as well as addressing a few privacy issues that I hadn’t previously known Firefox had. It is, in many ways, just Firefox, but Not Stupid, which is enough to get it a recommendation.
Paint.net – Because sometimes Photoshop is overkill
(Paint.net screenshot)
Much of writing for the Internet isn’t writing. I am not good at image editing, but it occasionally becomes necessary, so I need to have a decent art program on my machines. I used Photoshop for a while, but for my bare-minimum purposes it’s always been a bit like keeping a jackhammer around in case I need to drive a nail. Worse, it’s an Adobe product, and if there’s something a software company has ever done that’s annoyed you, Adobe did it first or is doing it more enthusiastically.
There are a few decent alternatives to Photoshop out there, such as GIMP, but I’ve gotten the most used to the freeware Paint.net. Some of it is because I appreciate their stubborn refusal to rework their website in the last 20 years – look at that beautiful Web 1.0 design – but Paint.net does everything that I, a permanent novice, need it to do. It’s a welcome dispatch from an era in which programs just worked, instead of trying to ensnare you in their consumer web.
LibreOffice – Open-sourcing my office apps
This article, in production, via LibreOffice. (LibreOffice screenshot)
I’ve been using this open-source replacement for Microsoft Office for years, but before recently, all my recommendations always came with a caveat. LibreOffice did everything I needed it to do – spreadsheets, word processing, direct conversion to .pdf – but played notoriously poorly with other applications in its lane. It couldn’t save a new document as a .docx (.doc, yes, but not .docx) and frequently went haywire whenever someone tried to open a LibreOffice file in another program.
That got quietly ironed out at some point without my noticing. I’d reinstalled LibreOffice on a new computer, and over the course of using it, I noticed that all my previous problems simply no longer applied. It’s now a perfectly viable alternative for all my local word processing needs, and has been working almost flawlessly for the last couple of years. Almost every piece I write starts locally, with a blank LibreOffice document.
Notetab Light – Plain text can be the best text
Another project, in production, via NoteTab Light. (NoteTab Light screenshot)
If I’m not writing in LibreOffice, I’m using this long-running freeware Notepad replacement. Sometimes, such as when you’re writing HTML, coding by hand, or filling out a wiki, plain text is all you need or want.
I had a similar app on my Mac way back in the day. When I made the switch to PC gaming in the 2000s, a pal recommended Notetab Light to me as a solid alternative. They were right, and ever since, NoteTab has always been one of the first things I install on a new computer.
Notetab Light is a useful way to get more customization options out of the most basic text imaginable, such as font size, background color, and automatic backups, with tabbed browsing for easy reference. In a day and age when Microsoft is trying to cram Copilot into everything including Notepad, I can rely on NoteTab to only ever do exactly what I told it to do.
Startpage – Google without the hassles, literally
Google, without modern Google. (Startpage screenshot)
The problem I’ve encountered with finding an adequate replacement for Google Search is that there isn’t one. A couple independent search engines come close, such as DuckDuckGo, but every so often I still have to go back to Google to get the results I need. My hope is that before too much longer, someone will come out with a functional search engine that’s a deliberate throwback to Google from its “don’t be evil” era.
Right now, the closest thing to that is Startpage, which is essentially an anonymizer for Google. It removes the AI overview and the tracking functions in favor of just giving you some semblance of what you’re actually looking for. It’s a little more convenient than simply adding “reddit” or “-ai” to the end of every search you make.
Protonmail – For Gmail refugees
(Protonmail screenshot)
This might be the most painful switch I’ve made, as I was an early adopter on Gmail. My account has fossilized layers of old emails that go all the way back to almost the beginning of my career. My history lived on that website, which is partially my fault for never deleting or locally archiving anything. Google keeps trying to inextricably bind Gemini into Gmail, though, so away I go.
Protonmail is generally marketed on the basis of its privacy measures, such as end-to-end encryption, but it’s also the natural first port of call for anyone swapping off of Gmail. You can set up auto-forwarding with ease, the UI is comparable if not identical, and its spam filters have yet to fail me. The only real drawback is that it gives you a fraction of the space of a new Gmail account, at “only” 1 GB, so now I have to be one of those “inbox zero” zealots.
Bluesky – What Twitter used to be (still terrible)
(Bluesky screenshot)
Microblogging platforms are, of course, a disease. They encourage the worst kinds of useless communication. They are also really good for quickly gathering information, so at least for what I do, they’re a necessary evil.
The ongoing prominence of Grok wasn’t why I stopped using Twitter, but it was a non-trivial factor. I joined the general exodus to Bluesky in 2024 and haven’t looked back, outside of the occasional bout of trainwreck syndrome.
Sadly, the overall Bluesky experience as of now indicates that most of what you hate about microblogging is due to microbloggers, and that’s platform-agnostic. Microblogging is simply a poor format for nuance or extended discussion. Either you try to express something complicated and your thoughts read like a telegram, or you don’t and you’re communicating exclusively in sound bites.
In addition, the Bluesky team has been talking up the benefits of “vibe coding” recently, which suspiciously coincides with the platform’s newfound tendency to crash without warning. It’s likely not a question of whether Bluesky ends up in the same agentic hell as post-Musk Twitter, but when.
For right now, however, Bluesky has its uses. It’s Twitter c. 2014 or so, providing an online home for a murderer’s row of writers, academics, journalists, and scientists. While it’s also got an inordinate supply of humorless wokescolds and troll accounts, Bluesky is still an interesting place to get news, see art, promote projects, and keep up with all your favorite writers. (And me.) While scrolling through Bluesky, however, you have to ignore its slowly burning fuse.
Bring back the dumb Internet
It’s not possible to get AIs all the way out of my digital life in 2026, more’s the pity. Sites like YouTube and LinkedIn constantly put it front and center, my phone’s constantly trying to turn AI assistance back on, and the handful of holdouts against LLM infestation slim down by the day.
At the same time, however, the current environment has given me a new appreciation for certain things that I never used to think twice about. When you can no longer take it for granted that something was produced by a human, there’s a new appeal to any media’s telltale signs of human imperfection: pencil marks, missed notes, filler words, speaker feedback.
That’s my new justification for any mistakes I make, by the way. They’re the proof I’m human.
My primary takeaway from these last four months, however, has been that I don’t feel as if I’ve missed anything. At time of writing, work-related LLMs primarily strike me as a series of solutions in a frantic search for matching problems. They don’t improve my efficiency as advertised, they actively impede my research, they dramatically expand my personal carbon footprint, and they’re being used to bring about an economic crash by an all-dork incarnation of the Legion of Doom. There’s no good reason to use genAI. Whenever I mention my personal anti-AI stance, I usually get told that I’m at risk of losing everything; practically, I’ve lost nothing.
If this story’s got one moral, that might be it. There’s nothing inevitable about AI.
MAI‑Transcribe‑1 is Microsoft’s first‑generation in‑house speech recognition model. It supports 25 languages and is optimized for real‑world, noisy enterprise audio, such as meetings and call centers.
Key highlights
Enterprise‑grade transcription accuracy
Designed for multilingual and accented speech
Lower GPU cost compared to prior Azure speech offerings
MAI‑Voice‑1 (Text‑to‑Speech)
MAI‑Voice‑1 is a high‑fidelity voice generation model capable of producing natural, expressive speech while preserving speaker identity over long‑form audio.
Key highlights
Generates up to 60 seconds of audio in ~1 second
Supports custom voice creation
Optimized for voice agents and conversational systems
MAI‑Image‑2 (Text‑to‑Image)
MAI‑Image‑2 is Microsoft’s highest‑capability text‑to‑image model, already ranking among top image models used in production Copilot experiences.
Key highlights
High‑quality photorealistic image generation
Accurate in‑image text rendering
Production‑ready latency and cost profile
Why This Matters for Azure Developers
For Azure developers, this launch changes three things fundamentally:
First‑party AI stack Developers can now build speech, voice, and image workloads without relying on external AI providers.
Enterprise‑ready by default These models inherit Azure RBAC, Managed Identity, compliance, and governance through Microsoft Foundry.
Agent‑first design MAI models are designed to be embedded inside AI agents, not just called as single APIs
Below is a common enterprise architecture using MAI models.
Sample Code Calling MAI‑Transcribe‑1:
Sample code
What Changed with MAI Models: Before vs After (Developer Perspective)
Microsoft’s MAI models are not just new endpoints — they represent a fundamental shift in how Azure developers build multimodal and agent‑based AI solutions.
High‑Level Comparison
Aspect
Before MAI (Azure & External Models)
After MAI (MAI‑Transcribe, Voice, Image)
Model Ownership
Heavy dependency on third‑party models (OpenAI, external TTS/STT providers)
First‑party Microsoft‑built models, operated and optimized by Microsoft
Dealing with bugs is a natural part of software development. But it can also be among the most costly, especially when they don’t get discovered until later in the development lifecycle. The daunting part is that many bugs aren’t immediately obvious.
Issues like memory leaks, default credentials, and hardcoded tokens are easily missed in manual code reviews, going relatively unnoticed until they cause problems late in development or post-launch. This can spike the cost of development through security vulnerabilities, downtime, reputational damage, and unwanted spending on rework.
That’s where static code analysis comes into play. It changes the way you approach code defects by shifting detection earlier in the process, prioritizing fixes without running code, and minimizing the impact and cost of bugs by making changes quicker and easier.
Let’s take a closer look at the costs associated with software bugs and explore how static code analysis helps save you money on related fixes.
Table of Contents
The true cost of software bugs
Every undetected bug comes with a price. But the scale might come as a surprise. According to a report by the Consortium for Information & Software Quality (CISQ), poor software quality cost the US economy $2.41 trillion in 2022. That includes everything from application downtime and debugging to productivity drains.
In addition, IBM’s Cost of a Data Breach Report 2025 reports that the estimated average global cost of a data breach is $4.44 million, with many breaches traced back to software bugs.
The cost of software bugs isn’t static. It escalates through the development, testing, and production stages. Essentially, the later in the process a bug is identified, the more it costs.
A 2010 study from the IBM System Sciences Institute shows the value of early bug identification. It said a bug identified at the traditional testing stage can cost 15 times more to fix than one found during design. And this only climbs higher when bugs sneak through to maintenance, costing up to 100 times more.
The average cost of a bug quickly adds up, including:
Downtime and production outages, leading to revenue loss and expensive hotfixes to get back online.
Rework, which is more time-consuming and complex if bugs are discovered later in the process, when developers don’t have a fresh view of the code. If a bug is discovered during coding, the developer immediately knows why they wrote it that way and the decisions they took, so they can easily unpick it. When it’s discovered later, whoever is tasked with removing the bug needs to take time to understand what the original developer did and why before they can fix the problem.
Context switching, when developers constantly need to shift tasks, leading to increased errors and more time and money spent on fixes.
Security breaches and non-compliance, which can cost almost three times as much as compliance, thanks to fines and reputational damage.
Technical debt through wasted developer time that could be spent reducing existing maintenance needs.
How static code analysis reduces bug costs
Static code analysis transforms how you handle code quality. Applying a shift-left mindset brings crucial tasks like testing and code quality to the front of the timeline, reducing the cost of required fixes in several ways.
Early detection, easier fixes
Earlier detection means changes are actioned at the cheapest point, before bugs reach QA or production. Faster feedback loops also let your developers rework code while the context is fresh. No unpicking or trying to understand someone else’s thinking later in the process means bugs can be fixed instantly, rather than taking days.
Lower production risks
Undetected bugs can wreak havoc in a live environment. Static code analysis flags security issues and vulnerabilities before merge. So you can avoid incidents, rollbacks, potential financial penalties, reputational damage, and the added cost of emergency developer resources.
Freeing up your team
Static code analysis frees your team up and unblocks backlogs. Automating repeatable checks reduces the burden of manual code review and debugging, allowing your team to focus on more complex issues, coding, and improving development efficiency and costs.
Repaying your technical debt
Enforcing code quality standards keeps codebases maintainable and reasonably inexpensive to run. That lets you focus on reducing your technical debt, rather than watching it further stack up and adding mental load.
Static code analysis in CI/CD pipelines
Static code analysis maximizes its cost-saving powers when deployed as part of the CI/CD (continuous integration and continuous delivery/development) pipeline. As your driver of code quality, it doesn’t just help you spot bugs, it stops them from ever reaching your codebase.
When you run static code analysis on every commit, you automatically check for issues as part of your standard development lifecycle. By checking code quality and security vulnerabilities, including those highlighted by security coding standards like OWASP, you ensure errors are spotted and fixed before code is merged into the main branch.
Failed quality gates in your CI/CD pipeline stop progress when the code doesn’t meet the required standard. Your developers must fix these and rerun the full or partial CI pipeline before progressing, meaning identifiable bugs simply never reach your codebase.
This significantly reduces costs in the long term by removing the ability to bypass failed quality gates, which can lead to increased technical debt, security problems, and production bugs.
How Qodana helps your teams control bug costs
Qodana reinvents your code quality processes. It lets your development team identify issues and fix them earlier through real-time feedback, consistent code standards, and suggested fixes.
That means you deliver secure, high-quality code without incurring the costs of refactoring and downtime. And all within the environments your team is already working in, for smooth integration.
The Qodana code quality tool is built on and uses the linters of JetBrains IDEs, trusted by more than 18 million developers since 2001, and integrates with tools developers already use. It drives code quality and reduces debugging costs through:
Ready-to-use pipelines for popular CI systems such as Azure Pipelines, CircleCI, Jenkins, GitHub Actions, GitLab CI/CD, and more.
Consistent rules and code quality checks across local development, IDE, and CI.
Quality gates that stop risky code before merge, minimizing potential future technical debt.
Clear and actionable reports that suggest automatic fixes and reduce repair time and associated costs.
Scenario: How to find and reduce bug costs in testing
How does static code analysis reduce costs in practice? Let’s say your team is working on a project to improve the design of your product and add new features. However, a code or configuration change unintentionally causes a security weakness by hardcoding secret values that have embedded API keys.
The result is that these values could be exposed to anyone with access to the codebase, including version control history. If the bug goes undetected, your systems will be vulnerable to unauthorized access and data breaches, resulting in downtime, reputational damage, and more time, resources, and money spent on fixes.
This can also be caused by code changes that weaken security by:
Logging sensitive data, such as credentials, leading to security and compliance risks.
Using insecure cryptographic APIs or misusing secure ones.
Missing authentication checks that may result in information exposure.
Without static code analysis
Without static code analysis, this vulnerability could easily make it through manual code review. Because it’s not obvious, it might pass functional testing and not be uncovered until close to or after release, during a security audit, or penetration test.
Worse still, if the issue makes it into your shipped product, it can even be found and exploited by an attacker, costing far more than just the resource needed for debugging.
Fixing the problem in a live environment can require coordinated patches and quick fixes, which may cost much more than if the error was detected and rectified during development. It can also lead to:
Additional resource costs for personnel and security reviews to fix the issue.
Large fines by regulatory bodies, such as the SEC (Securities and Exchange Commission) and FTC (Federal Trade Commission).
Delayed certifications, which may lead to financial, operational, and legal penalties.
Reputational damage and the associated costs of lost business.
With static code analysis
Static code analysis significantly reduces the cost of dealing with such a vulnerability. At commit or pull request, the vulnerability is flagged and progress stopped. The developer working on that code is automatically alerted and required to fix the issue before merging code. This stops the bug in its tracks and prevents it from becoming part of your wider codebase, meaning there’s a quicker fix and no fallout.
The process ensures security is a proactive priority, rather than a reactive expense. It helps mitigate vulnerabilities causing security problems during testing and execution. It also reduces the risk and high costs of compliance breaches.
Reduce software bugs and costs with Qodana
Static code analysis is an important part of lowering the cost of software bugs and fixes. Identify problems before they escalate into expensive issues.
The Cursor we’ve come to know and love has always been an IDE with AI assistance. Working with Cursor gave a similar look and feel to working with IDEs of days gone by (VS Code, JetBrains, etc). On April 2, 2026 Cursor 3 launched with its dedicated Agents Window. The Agents Window is a standalone interface where the user can describe a task to an agent and the agent should be able to execute the task completely. Sound familiar?
Cursor’s new Agent Window looks almost identical to Claude Code (Anthropic’s terminal-based coding agent) and other AI chatbot interfaces. This didn’t happen by accident. In my opinion, this was done as a direct response to Anthropic (Claude Code) shipping code interfaces that do what Cursor does without the middleware layer.
Looking similar to Anthropic and OpenAI isn’t the same as functioning the same way. To find out whether or not Cursor 3’s new interface kept the tool competitive with Claude Code, I ran the same tests on both tools using the the popular open-source repo HTTPie.
The test
My testing focused on debugging. I took two bugs, both well documented but only one with a suggested solution, and prompted both tools with the exact same prompts. I’m including the details in case you want to run your own test.
The prompt I used for both Claude Code and Cursor 3 was:
There is a security bug in this codebase where HTTPie writes HTTP response headers and body content to the terminal without stripping terminal control sequences. A malicious server can embed ANSI escape codes in responses to manipulate the terminal display, change the terminal title, or inject clipboard content.
The affected files are:
httpie/output/streams.py – in BaseStream.__iter__(), EncodedStream, and PrettyStream
httpie/output/writer.py – in write_stream() and write_stream_with_colors_win()
Please fix this by adding a sanitization function that strips terminal control characters when output is going to a TTY. The sanitization should only apply when env.stdout_isatty is True, not when output is piped to a file. Add the fix in the appropriate place in the output pipeline.
There is a bug in the –download feature. When a server responds with Content-Encoding: gzip and sets Content-Length to the size of the compressed payload, HTTPie incorrectly reports “Incomplete download” because it seems to be comparing Content-Length against the uncompressed size rather than the compressed size.
According to RFC 9110, Content-Length should reflect the encoded (compressed) size when Content-Encoding is present. Browsers, curl, and wget all handle this correctly.
The error looks like this: Incomplete download: size=5084527; downloaded=42846965
Please find the relevant code and fix it.
How Cursor performed
Cursor fixed both bugs with no additional prompting required in its Agents Window. For the first, it implemented the fix across two files, covering more escape sequence types than the bug report suggested. For the second, it traced the download pipeline, identified the root cause in downloads.py. The tool compared compressed content length against decompressed byte counts and wrote a targeted solution plus a regression test, all without being told where to look.
The developer experience was quick and painless. By far the easiest debugging I’ve ever done, no print() statements needed. Cursor read the codebase, made the changes, and reported back. The interface looks like a chat window which immediately felt familiar and gave a sense of ease.
One caveat: Cursor couldn’t run the test suite itself. It flagged that pytest wasn’t installed in its environment and handed verification back to me. When I ran the tests manually, both fixes passed. Initially, I thought nothing of it. I always ran my own tests so nothing new here ….
How Claude Code performed
No surprises here. Claude Code executed without the need for intervention. Claude Code executed through my MacBook’s terminal and felt nothing like an IDE. Then again Cursor’s Agents Window didn’t feel like an IDE either. Another seamless developer experience.
On the first test it implemented the fix correctly, caught a bug in its own logic, corrected it, and moved on. On the second it was notably fast, 54 seconds from prompt to remediation. It also noticed a FIXME comment sitting on the exact line with the bug, something Cursor didn’t flag, and removed it as part of the solution.
The most distinct behavioral difference is that Claude Code asks for permission before editing files or running commands. Every change is surfaced for your approval before it lands. Cursor just acts. Depending on your working style that either feels like appropriate caution or cause for concern. In this case, since we were looking for an agentic workflow with the least amount of manual intervention possible, both workflows were acceptable.
What do we think?
The version of myself who spent hours and hours debugging is in awe right now. Is debugging becoming a thing of the past? When it comes to the preferable software, it really boils down to personal taste because they both executed seamlessly. I’m constantly blown away at how agentic tools are changing the developer experience. I remember spending hours debugging, console logging, etc.. and now it’s as simple as, “Hey, there’s a bug. Plz fix”.
Before Cursor added the Agents Window, the products were more differentiated (speaking specifically for the type of work we tested here which was debugging). I think adding the Agents Window was necessary for Cursor to stay competitive when it comes to agentic chat/ hands-off workflows as it seems like the industry is heading in that direction.
As for Claude Code being able to execute inside the computer’s terminal, sure, that could be a benefit for someone who prefers to work in their terminal. To me, it didn’t matter. Direct terminal access wouldn’t be a selling point either way. I also wouldn’t be surprised if eventually Cursor added the ability to execute inside a MacBook Terminal. The possibilities are endless and I imagine there are always more features on the way. No one wants to give up that market share. I can’t wait to see what comes out next.
Log in
