Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165434 stories
·
33 followers

Anthropic mathematician claims to have solved prestigious Millennium Prize problem with Claude

1 Share
Anthropic went public on November 19th, 2026. | Photo: Getty Images

Anthropic mathematician Levent Alpöge claims he has solved the Riemann hypothesis, one of mathematics' most notoriously difficult problems, with the help of Claude, cracking a puzzle that has eluded some of the world's best mathematicians for decades. If verified, it would mark yet another seismic achievement for AI in mathematics, and add to the upheaval already unleashed by OpenAI's previous, often inelegant forays into the field.

Alpöge's solution has yet to be verified independently. Anthropic has not commented or involved itself in Alpöge's announcement. In a document on his website, Alpöge says he texted Anthropic CEO Dario Amodei abo …

Read the full story at The Verge.

Read the whole story
alvinashcraft
10 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

JetBrains Air in GoLand: Build, Review, and Profile Go Code With Agents

1 Share

If you’ve ever built backend services in Go, chances are you’ve also written a webhook handler or two. They’re small and rarely get much attention – that is, until something breaks. A third-party provider sends a signed request, and then you check the signature, store the event, and reply. Sounds like three easy steps, but a lot can go wrong. A captured request could get replayed, a duplicate could get saved twice, or a forged signature could slip through. 

Coding agents are not likely to make these types of mistakes, so with code becoming cheaper to generate, handlers are a good task to give them. They can also write handlers faster than you can. But even with their suitability to the task, it is still on you to check that they got the details right if you want to avoid issues in production.

That’s where JetBrains Air in IDEs comes in. It gives you one place to start your preferred agents, follow their progress, and review their work. In this article, we’ll build a small webhook receiver, review the changes and send feedback straight from the diff, and then run a few follow-up tasks in parallel, each in its own worktree, that will all be merged together later. Finally, we’ll verify the combined output with GoLand’s tools, including the HTTP client and database tools. And to make things easier, we’ll let an agent profile the handler with our new profiling skill, goland-profiler.

Tag along to see how to create a working service you own and trust in a matter of minutes.

What we’re building

Our example is a small service that receives signed, Stripe-style payment webhooks and stores each event just once. We start with an empty Go module with nothing in it but a brief, BRIEF.md, that agents will use as a reference. You can copy it from the demo repository: air-goland-demo. 

These are the principles of our project:

  • Standard library only: Our project uses net/http for routing, log/slog for logging, and an in-memory store, so the service runs with go run and needs no extra setup.
  • One endpoint only: POST /webhooks/{provider} accepts a JSON event and stores it once by its ID. A new event gets 202 Accepted, and a redelivery gets 200 OK.
  • Signed requests: Every request carries a signature, and anything with a missing or invalid signature, or a timestamp older than five minutes, gets 401 Unauthorized.

Laying out the core principles is something you don’t necessarily want to hand off to agents straight away, because that’s where you decide on the definition of “done”. Also, because several agents will use it at the same time, the brief is what ties their work together. Naturally, the better you scope your project, the easier it will be for the agents to follow along and make fewer mistakes.

First, we’ll ask an agent to build the service from BRIEF.md – the store, the handler, the signature check, and main.go. Once that’s in place, we’ll take on three follow-up tasks: an SQLite store, extra tests for the signature check, and a set of signed test requests for GoLand’s HTTP client. When we’re done, the core of the service should resemble our demo repository – a reference version of the service you can use to try out our new Profiling skill (more on that later). The reference keeps only the in-memory store, so it doesn’t include the SQLite store or the HOOKRELAY_DB setting your agent adds.

Getting started with Air in GoLand

In GoLand 2026.3, Air has become the default AI workspace (replacing AI Assistant), so there’s nothing to install – you’ll see it on your home screen after you update. You can choose which agents you want to work with, including Junie, Codex, Claude Code, or any other agent that supports the Agent Client Protocol (ACP).

There are three ways to start a session:

  • Agent widget: Click the widget in the main toolbar to start a session with your current preset, or click the drop-down button next to it to pick a different agent.
  • Agent Sessions tool window: Open it with View | Tool Windows | Agent Sessions.
  • Global prompt: Press Ctrl twice anywhere in the IDE, type your request, and press Enter. If you have code selected in the editor, it will be used as context.

Each session opens in its own tab. You can pick the model, the effort, and the access level (i.e. how much oversight the agent has). The first time you send a request, the agent may ask you to authorize it – with your service account, JetBrains AI, or a provider key you add under Settings | AI | Air | Accounts.

Launch your first agent task

First, we’re going to hand off the core of the service to Codex. With a properly defined scope, one agent with a sufficiently robust model should be able to build this simple service without any major hiccups.

  1. In the Agent Sessions tool window, click the drop-down button next to New Session and select Codex.
  2. Pick a model in the model selector below the text field.
  3. Enter the prompt and press Enter.

Here’s the prompt we used:

Build the service described in BRIEF.md: an in-memory event store behind a Store interface in internal/store, the webhook handler in internal/webhook, signature verification as net/http middleware in internal/middleware, and a main.go file that wires them together. Store each event once by its ID, replying 202 Accepted for a new event and 200 OK for a duplicate, and log with log/slog. Add table-driven tests and a benchmark for the handler.

Review changes

The easy part is done. Now it’s time to make sense of what the agent produced and see if it’s done everything right.

When an agent finishes a turn, the session lists the files it changed, with added and removed lines, under Since last turn. Click a file to open its diff, or click Review to step through all of them. Since this session works directly in your project, its changes also show up in the Commit tool window (⌘K). For sessions that run in a worktree, which we’ll get to shortly, Worktree Changes in the session header shows everything the agent has changed compared to the base branch.

Luckily enough, webhook receivers fail in pretty predictable ways. This is where your actual experience as a developer comes in handy. Instead of reading the diff top to bottom, you can check it against a short list of known offenders:

  • Constant-time comparison: Signatures should be compared with hmac.Equal. A plain == or bytes.Equal returns at the first mismatched byte, which can leak how much of a forged signature was right.
  • Raw body: The HMAC has to cover the timestamp and the body exactly as it arrived, not a re-encoded version of the parsed JSON.
  • Replay window: Stale timestamps should be rejected, or a captured request can be replayed indefinitely.
  • Size limit: Without http.MaxBytesReader, a client can send a body of any size, and the service will read all of it.
  • Read once: If the middleware reads r.Body to check the signature, it has to put it back for the handler.
  • Idempotent replies: Providers retry anything that doesn’t get a 2xx response, so duplicates – including one that loses a race to be saved – should get 200 OK.
  • Quiet errors: Error responses should carry a short, fixed message, while the details go to the logs. We covered this in our guide to secure error handling in Go.

Give feedback in the diff

If you find any mistakes, you can describe each change you want in the chat, but it’s quicker and leaves less room for error to point the agent at the right line of code instead. In the diff, click the chat icon in the gutter next to a line or selection of lines, type your note, and click Add Note or press Enter. You can also leave several notes and send them together.

Once you send the message, the notes stay attached to it as a read-only record of what you asked for. The agent picks up from there, and its next Since last turn list shows only what changed since then.

When you’re happy with the results, commit them from the Commit tool window (⌘K). This will be our starting point for subsequent tasks.

Run more tasks in parallel

Normally, you’d probably complete the tasks that we’ll work on in a sequence. But since they don’t really depend on each other, you can hand them out to agents all at the same time and review the changes as they come in. We’re going to create:

  • SQLite store: A persistent store behind the existing Store interface.
  • Tests for the replay window: Proof that the signature middleware rejects requests that are more than five minutes old.
  • Signed test requests: A way to try the whole service from GoLand’s HTTP client.

We will work with worktrees, so that agents don’t get in each other’s way. Here’s how to set them up:

  1. In the Agent Sessions tool window, click the drop-down button next to New Session and select the agent.
  2. Open the run mode list in the toolbar above the text field and select New Local Worktree. The session will get its own Git worktree and a branch.
  3. In the branch list next to the project name, choose the branch with your first commit as the base.
  4. Pick a model in the model selector below the text field.
  5. Enter the prompt and press Enter.

We’re going to give the SQLite store to Claude with this prompt:

Add an SQLite implementation of the Store interface in internal/store, using the pure-Go driver modernc.org/sqlite, so the service still runs with go run. Make the event ID the primary key, so a duplicate insert returns the same error as the in-memory store. In main.go, use SQLite when HOOKRELAY_DB is set to a file path, and keep the in-memory store as the default. Add table-driven tests against a temporary database. The driver is the one exception to the brief’s standard-library rule.

The other two tasks are pretty routine, so they’re a good fit for Junie Lite – our coding agent with a cost-efficient model for everyday tasks that works with your JetBrains Account. Here are the prompts:

Add table-driven tests for the signature middleware in internal/middleware to check that a request is rejected with 401 Unauthorized when its timestamp is more than five minutes old, and accepted when it’s just inside the window. Only change test files.

Create requests/webhooks.http for GoLand’s HTTP client with three requests to POST {{host}}/webhooks/stripe: a valid event, the same event sent again, and an event with a bad signature. Sign the first two in a pre-request script, as described in BRIEF.md. In a dev environment, put the host in requests/http-client.env.json and the secret in requests/http-client.private.env.json. Give each request a response check for the status code the brief expects.

All three agents now work side by side, each in its own worktree. The Agent Sessions tool window shows which sessions are In Progress, which need your input, and which have finished with results you haven’t looked at yet, so there’s no need to keep clicking through tabs to check. If you turn on Time and Cost under the Filter icon, you can also see how long each session has been running and what it has cost so far.

If an agent needs a decision from you – like permission to run go test – its session is marked as waiting for input, and you can answer right in its tab. You can also queue follow-up prompts while an agent is busy. They’re sent as soon as it finishes its current turn.

Tie it all together

Each of the new additions has only been tested on its own – the SQLite store against a temporary file and the new tests against the middleware, while the test requests haven’t been sent anywhere yet. So now that we want to combine the branches, it’s time to check the whole thing.

First, you want to review each worktree the same way you did the original service: Review the changes and leave notes in the diff.

Be mindful that test requests have to sign exactly what the middleware checks, ensuring that the same string with the same secret in the same header format. The secret belongs in the http-client.private.env.json, not in the shared environment file or the script.

Once you’re happy with the results, you can bring these three branches together:

  1. In your project, check out the branch the work should land on. Air cherry-picks onto whichever branch is currently checked out, not the worktree’s base branch.
  2. In each session’s header, click the drop-down button next to Commit, select Commit, and cherry-pick all.

Send the test requests

The private environment file is in .gitignore, so Junie Lite’s copy stayed behind in its worktree. Create your own in requests/http-client.private.env.json:

{"dev": {"secret": "dev-secret"}}

Next, start the service with SQLite: Open the run configuration for main.go (Run | Edit), add HOOKRELAY_DB=hookrelay.db under Environment, and run it. Then open requests/webhooks.http, select dev in the Run with list, and click Run All Requests in File.

A pre-request script signs each request before it’s sent, and a response check after each one compares the status code with what the brief expects. That means you don’t have to read the responses yourself – the Tests tab of the Services tool window lists each check as passed or failed.

Check the database

The database tells you what the HTTP client stored. Open the Database tool window, click +, choose Data Source | SQLite, and point it at hookrelay.db in the project folder. GoLand may offer to download the SQLite driver first. Next, open the events table, or run a quick query in the query console (adjust the table and column names to whatever your agent chose):

SELECT id, COUNT(*) FROM events GROUP BY id;

The valid event and its duplicate should leave one row between them. Since the database keeps its data between runs, delete hookrelay.db before you send the requests again, or the valid event becomes a duplicate and its check fails.

Let an agent profile the handler

Voilà! Our agents’ service works, but for now, nothing tells us how it behaves under load. Webhooks tend to arrive in bursts – after an outage, for example, when a provider redelivers its whole backlog at once – so a slow handler is more than a theoretical problem. Normally, this is where you’d reach for the profiler. With GoLand 2026.3, you can hand that job to an agent, too.

To demonstrate the profiling skill on an actual problem, we’ll switch to a reference version of this service that you can find on GitHub. It’s a finished receiver built to the same brief, with one difference: We’ve left a performance problem in it on purpose, so you can repeat every step below on your own machine.

Where skills can help

A skill is a set of instructions that teaches an agent how to handle a specific type of task. On its own, an agent can only work with what it sees from the outside: It reads the code, runs commands, and parses their output. GoLand’s skills connect supported agents to the IDE’s own tools so that the agents can use them more effectively, allowing the agents to know which profile to take, how to read it, and how to tell whether a fix actually worked.

The goland-profiler skill is bundled with Air and works with Claude Code, Codex, and Junie. These agents can run your application with GoLand’s profiler, record a CPU profile while it handles traffic, and read its hot paths and line-level hints. Thanks to the skill, there’s nothing to set up – the agent loads the skill when a task calls for it, or you can attach it explicitly by typing / in the prompt or by clicking Add and choosing Skills.

How to use it

To try out the skill, open the demo repo in GoLand and stay on its main branch. The service needs traffic to profile, so the repo comes with a small load generator that sends signed events for 30 seconds. Start a new session with this prompt:

Run the service with /goland-profiler and record a CPU profile while go run ./cmd/loadgen sends it traffic. Tell me where the handler spends its CPU time and memory, and what you would change. Don’t edit any code yet.

We suggest asking for a diagnosis first so that you can check the agent’s reading of the profile before it acts, and decide what you want to change based on evidence.

The agent starts the service with the profiler, records CPU while the load generator runs, reads the hot paths, and comes back with the culprit: validateEventID compiles its regular expression on every call. In our run, validateEventID accounted for 69% of the CPU use, with regexp.MustCompile being the hottest call. The allocation churn was keeping the garbage collector busy on top of that.

You don’t have to take the agent’s word for it, though. The profile it captured is an ordinary Go profile, so you can open it in the Go Optimization tool window and look at the flame graph yourself, where regexp.MustCompile sits right under validateEventID and takes up most of the handler’s width.

The fix is pretty straightforward: Compile the pattern once, at the package level, instead of compiling on every request.

// Before: the pattern is compiled on every call
func validateEventID(id string) error {
	var eventIDPattern = regexp.MustCompile("^evt_[A-Za-z0-9]{24}$")

	if !eventIDPattern.MatchString(id) {
		return fmt.Errorf("invalid event id %q", id)
	}

	return nil
}
// After: the pattern is compiled once, when the package is initialized
var eventIDPattern = regexp.MustCompile("^evt_[A-Za-z0-9]{24}$")

func validateEventID(id string) error {
	if !eventIDPattern.MatchString(id) {
		return fmt.Errorf("invalid event id %q", id)
	}

	return nil
}

Sharing one compiled pattern across all requests is safe in this case, since a *regexp.Regexp can be used by multiple goroutines at the same time, but it’s worth confirming first before you let your agent run loose. We asked the agent to apply the fix and profile the service again under the same load. To put numbers on the difference, we also ran BenchmarkHandler before and after.

BeforeAfter
Time per request13,141 ns2,748 ns
Bytes per request16.4 KB6.7 KB
Allocations per request12625

After the change, the benchmark is about 4.6 times faster with 59% fewer bytes and 80% fewer allocations per request. Times will vary by machine, but the drop in bytes and allocations should be about the same.

Try it yourself

You can repeat this exercise on your own machine to play with the skill. The repository has two branches:

  • main: a finished service with a planted slow event ID validation.
  • fixed (use for reference): the same service with the regular expression compiled once.

To try it out:

  1. Clone the repository and open it in GoLand 2026.3. You’ll need Go 1.27.3 or later.
  2. Start an Air session with Claude Code, Codex, or Junie.
  3. Ask the agent to profile the running service – you can use the prompt from the previous section.
  4. Once the agent has applied its fix, compare your working copy with ours by running git diff origin/fixed, or view our fix on its own with git diff origin/main origin/fixed.

Your agent’s fix doesn’t have to match ours line for line. But it should hold up against the same checks: The tests pass, and the new profile no longer has regular expression compilation at the top.

Run the final checks before you merge

Whether you’re merging the service or the profiling fix, run the checks one last time on the final code. Then, reset the store and run webhooks.http again so the first request is a new event, and restart the service if it uses the in-memory store  or delete hookrelay.db if it uses SQLite. If everything checks out, commit from the Commit tool window (⌘K) and merge the branch. A pull request is always a good place for a human to look at the changes – especially ones where three agents were in the driver’s seat.

Code the way you want

AI has changed the coding game to the point that it’s no longer a question of whether you use agents, but how you use them. At JetBrains we support all your workflows. Whether it’s in the IDE or the terminal, whether you use agents for small tasks or orchestrating entire services, whether you YOLO your way through or meticulously check every change, Air is there to help you with the one thing that hasn’t changed: your ownership of your code.

This quick demo only scratches the surface of what Air in IDEs can do, but it’s a good starting point to explore more. Let us know how you like this new addition to your IDE and what features we should demo next. And keep an eye out for more tutorials and skills in the coming months.

Happy coding,
The GoLand team

Read the whole story
alvinashcraft
11 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Replit’s Nik Biridzhyan: AI Closed the Tech Gap, Not the Skill Gap

1 Share

At Web Summit in Lisbon, I caught up with Nikita (Nik) Biridzhyan from Replit’s Forward Deployed Engineering team for EMEA to discuss how AI-powered development is opening software creation to non-developers, reshaping engineering teams, and challenging traditional ideas about what makes a good developer.

Vibe coding is evolving into agentic engineering

AI agents can now build whole applications from a prompt. But how far does vibe coding get you when the software has to meet real engineering standards and run in production? I asked Nik where the limits are.

He thinks the industry has already outgrown the term. After two years of fast progress, he says, we’re moving from vibe coding to agentic engineering.

For Nik, the biggest part of that shift is who gets to use these tools. People with no technical background now work with the same coding agents professional engineers do, and that’s shrinking the technology gap. Building something complex is a different story, though:

So that technology gap, I think, is narrowing now and will narrow even further with time. However, I think the skill gap remains. So knowing how to create these applications and, you know, I think especially on the more complex side of things, this is where the gap will exist.

Business users build the apps, engineers take over when they matter

With Replit’s Cloud Agents, non-developers can now contribute to company codebases. Is that real democratization, or just more AI-generated code for engineers to review?

Nik doesn’t see engineers losing their core products. Professional teams will keep owning established software, while business users build and run more apps of their own.

Every company, he says, has a pile of ideas that never make the engineering roadmap because something else always comes first. With agents, the people who had those ideas can build them, and engineering doesn’t have to own every project.

He sees the two working side by side, with a clear path for apps that get too important to stay with the business:

And funny enough, in Replit, we have a thing called graduation. We call it graduating from Replit. So when the app that a business user has created reaches that kind of level of importance where the business says, wow, okay, you know what? This is now becoming mission critical. We will actually graduate from Replit and let software engineering teams take over.

AI agents can build almost anything, as long as you know what you want

When several AI agents work on the same project, the obvious worries are technical: context management, coordination, code quality. I asked Nik which of those would be hardest to solve.

None of them, as it turns out. He says collaboration on Replit is already easy, even fun. The real problem comes before the agents write a single line, and that’s figuring out what you want and turning it into clear requirements:

I think the challenge in here isn’t technical, actually. It’s the challenge is always knowing what you want to achieve. So collaboration on Replit is super easy, and it’s honestly been a joy to collaborate with others on the projects. But it’s knowing exactly what you wanted to build and communicating that clearly, I think, remains a challenge. So having that scoped-out requirements is the biggest thing for me.

How much should an AI agent touch production? Replit lets you decide

Replit’s Monitoring Agent goes a step further. It looks into production incidents and can deploy a fix without anyone signing off. So how much control should developers hand over, especially when an automatic fix makes things worse?I asked Nik where he’d draw the line.

Replit doesn’t draw one for everybody, he says. It lets users decide, because different companies, and even different apps inside the same company, need different amounts of oversight:

So with that specific thing, we want users to choose if they want to just be notified of any issues, if they want an agent to notify them and draft a fix and then wait for their approval, or if they want to fix it completely autonomously.

Two years of AI pilots, and most companies still can’t show results

European companies are starting to roll out AI coding agents, so I asked Nik which is harder: getting developers to trust AI-generated code, or getting security teams to let those agents near critical infrastructure.

Security, he says. But there’s another hurdle too, which is convincing the business that AI is worth the effort at all. Companies have been experimenting for a while now, and most have little to show for it:

Most companies have been running pilots for the past two years without any meaningful results. So there is a little bit of convincing on the security side and also convincing on the business side: hey, this is, this is actually valuable, we should be doing that.

Taste will be the top developer skill as AI slop piles up

For my last question, I asked Nik what would make a developer valuable in 2027, if agents can write, test, deploy and maintain software on their own. I also asked what happens to junior developers if they lose the work that usually turns them into seniors.

He went straight for the skills part. He didn’t name a language, a specialization or a discipline. Instead, he offered what he called a hot take:

You ask for skills, I’ll give you one: taste. As more things are possible with AI, I think we’re entering an era where there’s a lot of AI slop. And so having taste, which is determining what’s actually quality, how you share it with colleagues, what is a good standard, and having that human determination to judge the work of AI agents, I think that’s going to be a number one skill that will determine if you’re going to be successful going forward or not.

The post Replit’s Nik Biridzhyan: AI Closed the Tech Gap, Not the Skill Gap appeared first on ShiftMag.

Read the whole story
alvinashcraft
11 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Microsoft To Do fan? I've got (bad) news for ya...

1 Share

Yesterday it was announced that Microsoft was killing off one of it's best apps, To Do: "Microsoft is killing its great tasks app in favor of its worse tasks app". This is a real bummer as the app is easily one of the best I've seen. Simple, clean, only does what it needs to do, and even as someone who is pro-AI, its one of the few apps that have resisted the urge to add AI just to add AI.

Obviously To Do apps are everywhere, and nearly every demo out there uses the same idea, but this one really clicked with me. I used it as a dumping ground for blog ideas, to help me remember things to do before I travel, and more. Honestly, it was less a task list really and more a way to remember things that didn't feel like they should be 'notes'.

Sample list

I'm already thinking about a replacement for it, but in the meantime, I needed a way to export my data. The app itself has a link to do that... which leads to a page about exporting Outlook data. And heck, maybe that works? But I don't use Outlook. I Googled for other options and the best I could find was a site that felt slightly sketchy to be honest.

So with that in mind, I built a simple quick and dirty web based export: https://todoexport.netlify.app/ Hit up the URL, authenticate with Microsoft, and you can export either all your To Dos, or just the ones that aren't marked complete. You can get either a JSON export for processing, or HTML for easier reading.

The OAuth flow clearly states it will only be reading your data, but if you are concerned, you can check out the complete repo here: https://github.com/cfjedimaster/todoexport

Read the whole story
alvinashcraft
12 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Your Skills Don’t Count If Agents Can’t Find Them

1 Share

More API providers are publishing agent skills. Packaged instructions that tell an agent how to actually get something done with an API, rather than leaving it to guess from the spec. I’m a fan. But I keep running into providers who have done the work and get no credit for it, from me or from the agents. If you have skills and my agents can’t find them, it’s probably because they’re not registered.

Skills are a discovery problem

A skill sitting in a GitHub repo, a docs page or a zip file on a marketing site is useful to the developer who already knows it’s there. It is invisible to everyone else. An agent arriving at your domain fresh needs a path from your front door to the skill, and from the skill to the tools, SDKs and CLIs it depends on. Without that path, the skill may as well not exist.

This is the same problem I’ve been writing about with OpenAPI for years. Publishing isn’t the finish line. Being findable is.

What the catalog shows

On APIs.io the Agent Skills dimension is worth 5 of 153 agent readiness points. 7,461 providers have skills attached to their profile, 18.1% of the 41,129 it applies to. But only 769 are at full credit, and 6,692 are at partial credit. That gap is mostly about who wrote them. The dimension notes that 2,018 of 2,274 skill sets in the catalog are API Evangelist generated, which I do on providers’ behalf, and a derived skill earns a quarter of the award because it isn’t evidence about the provider. The catalog’s skills collection lists 1,845 skills you can browse and search.

Now look at registration. The A2A Agent Card dimension, a manifest at /.well-known/agent-card.json advertising identity, capabilities, skills, endpoint and auth, is published by 1,306 providers, 3.2% of the catalog. 838 of those are conformant. The Well-Known Catalog sits at 1,974 providers, 4.8%. So the places an agent looks to discover skills are far emptier than the places skills are being written.

Register them where agents look

If you have skills, here is the order I’d go in:

  1. Publish an A2A agent card on your own domain. It’s the one agent surface that can’t be derived on your behalf. It is served from your host or it doesn’t exist, which is exactly why I weight it above skills.
  2. List your skills in the card, and link each one to the tools, MCP servers, SDKs and CLIs it relies on.
  3. Add a well-known API catalog that points to the card, your contracts and your MCP servers, so there is one entry point.
  4. Then refine the skills. Make them more atomic, aligned with real use cases, and lint them before you hand them to an agent.

People want to start at step four. I get it, it’s the fun part. But a beautifully atomic skill no one can find scores the same as no skill at all.

Skills express domain expertise

The reason I care about this is bigger than a score. As the individual utilities behind APIs commoditize, what lasts is domain expertise, expressed as use-case skills over well-designed APIs and MCP tools. Skills are where a provider gets to say, here is how you should use us to get real work done. That’s valuable. It’s worth the extra hour to register them where agents will find them.



Read the whole story
alvinashcraft
12 minutes ago
reply
Pennsylvania, USA
Share this story
Delete

Why there are still no non-WebKit browsers on iOS

1 Share

Firefox on iPhone is growing fast across the world. This is especially true in the EU since 2024, when the EU Digital Markets Act (DMA) started requiring Apple to let people choose their default browser; millions have picked Firefox, and daily use on iOS has doubled. People want to choose the browser on their phone.

But there remains an important limitation to what is available on iPhones: Apple forces all browsers on iOS to be built on Apple’s own browser engine. 

This has meant that companies like Mozilla cannot easily bring the full range of Firefox features and functionality to iPhone users because many of these are built within our browser engine, Gecko. iPhones and iPads are unique in having this restriction. On all other major operating systems, including Apple’s macOS, people can access the Gecko-powered version of Firefox.

As a result of the DMA, Apple began allowing alternative browser engines on iOS in the EU. It published a set of conditions that companies like Mozilla must comply with to bring their own browser engine. At the time we said Apple’s rules made it “as painful as possible” for alternatives like Gecko. In the meantime, Japan also introduced new rules requiring alternative browser engines on iOS. Apple applied very similar conditions in Japan to those in the EU.    

Nearly three years since Apple introduced these conditions in the EU and almost a year since Japan, not one developer has been able to launch a non-WebKit browser on iOS. The reason is simple: Apple’s conditions remain unworkable. The real test of any rule is whether it delivers the change it was meant to achieve in practice. Compliance on paper alone falls short of that test.

Since the DMA came into effect we’ve been working behind the scenes to test and improve Apple’s conditions so that we can bring Gecko to iOS users. Those efforts have so far largely failed. 

One of the conditions requires us not to disclose non-public information related to the project, but here’s an example of what we are up against: to use Gecko, we can’t simply update the Firefox app people already use and love. We’d have to build a whole separate app, a second Firefox. Then we’d have to ask every Firefox user to download it, move their bookmarks, passwords and history across, and manually switch over, step by confusing step.

That’s a lot to ask of people who already made their choice. A significant proportion of people would understandably give up, including many who picked Firefox from the EU’s choice screen.  

The conditions Apple imposes, including a level of user friction Apple would never accept for its own apps, mean that the open door feels more like a trap door. 

Firefox users on iPhone chose an independent browser. They should get everything that comes with it, including Gecko, the last major browser engine not developed by a big tech company. We’ll keep pushing for a real level playing field, not an opening that drops independent browsers through the floor.

The post Why there are still no non-WebKit browsers on iOS appeared first on The Mozilla Blog.

Read the whole story
alvinashcraft
12 minutes ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories