For the past couple of years, using AI at work has mostly meant the same move: copy something, switch to a chat tab, paste, ask, copy the answer back. The AI was a destination you visited.

The last ten days pushed hard in the other direction. AI moving into the browser itself, into reusable packages of team knowledge, and into the cloud where it can work without your laptop open. Three announcements, one theme: AI is moving from a tab you visit to the place where the work happens.

What was announced

• 16 October: Agent Skills (Anthropic). Folders of instructions, scripts and resources that Claude loads when they're relevant to the task.
• 20 October: Claude Code on the web (Anthropic). Claude Code tasks started from the browser and run in the cloud, instead of only in your local terminal.
• 21 October: ChatGPT Atlas (OpenAI). A web browser with ChatGPT built in, available on macOS first.

ChatGPT Atlas: the browser as the assistant

Atlas puts ChatGPT inside the browser rather than in a tab of it. The assistant can see the page you're on, so "summarise this", "compare these two products" or "what does this error on the page mean?" don't need any copy and paste. OpenAI also showed an agent mode, where ChatGPT can take actions in the browser on your behalf.

The idea isn't entirely new: AI sidebars and assistant features have been appearing in browsers for a while. What's notable is OpenAI building its own browser around ChatGPT, rather than adding ChatGPT to someone else's.

For developers, I see three practical angles:

• Your users' browser may now read your pages for them. Clear headings, semantic HTML and readable content help assistants understand a page in the same way they help screen readers and search engines. Good structure was always worth it; now there's one more reader.
• Agents will fill in your forms. If an assistant can click and type in a browser, your forms will meet non-human visitors acting for real users. Clear labels and predictable flows help; so do the protections you already have, like confirmation steps for anything important.
• Prompt injection becomes a browsing problem. An assistant that reads web pages can be fed instructions hidden in those pages. That's a known, hard problem for every AI browser and agent, not just this one. I'd be careful about letting any browser agent act while I'm logged into sensitive accounts, and I'd keep an eye on what it's doing.

Agent Skills: packaged know-how that loads on demand

This one is less flashy and, for teams, probably more important.

A skill is a folder. At its centre is a SKILL.md file with a short name and description, plus instructions, and optionally scripts and reference files. Claude sees the short descriptions, and only loads the full skill when a task calls for it. So you can have many skills available without stuffing all of them into every conversation.

.claude/skills/release-notes/
├── SKILL.md          # name, description, instructions
├── template.md       # the format we publish in
└── collect.sh        # gathers merged PRs since the last tag

If you already package your workflow into instruction files and custom commands, this is the natural next step. The difference is when things load:

The scripts are the interesting part. Some jobs shouldn't be done by a model generating text each time: filling a document template, validating a file format, running a fixed sequence of commands. A skill can hand that work to a script that does it the same way every time, with the model deciding when to use it.

The obvious caution: a skill can include code that runs. Treat skills from outside your team like any third-party dependency. Read them before installing.

Claude Code on the web: the agent doesn't need your laptop

Claude Code has lived in the terminal (and recently in the IDE). Running it from the browser, in cloud environments connected to your GitHub repositories, changes how you hand work off: start a task, close the laptop, come back to a branch and a pull request.

It also makes parallel work easier. Several small, well-defined tasks can run at the same time, each in its own environment, each producing a diff to review. The guardrail question changes shape too: when the agent runs in a sandbox in the cloud, it doesn't have your local credentials, which is a good thing. Your review of the pull request becomes the main checkpoint.

What this means

Put the three together and the direction is clear:

• Context is moving to the AI, instead of you pasting it in: the page you're reading, your team's packaged know-how, your repository.
• The AI is taking actions, not just answering: clicking in a browser, running scripts, opening pull requests.
• The human role is shifting toward reviewing and deciding, which makes clear instructions, small tasks and careful review more valuable, not less.

What I'd try this week

• Turn one repeated team process into a skill, with a script for the part that must be exact.
• If you have Atlas or another AI browser, open your own product in it and see how well the assistant understands your pages and forms.
• Hand one small, well-tested task to a cloud agent and review the pull request as strictly as you would a colleague's.

Which of these would you actually use: an AI browser, packaged skills, or agents running in the cloud? And which one makes you most nervous?