Some months, nothing ships. Then there's November 2025, when in the space of nine days we got a new OpenAI model, a new Gemini generation with a brand-new development environment, and a new PHP release with a feature PHP developers have wanted for years.

If you've been heads-down on a deadline, here's the short version of what happened, what it means for working developers, and what I'd actually do about each one this week.

12 November: GPT-5.1

OpenAI released GPT-5.1 on 12 November, an update to the GPT-5 models that arrived in August. For developers, a point release like this is less about a dramatic new capability and more about everyday behaviour: how well it follows instructions, how it handles long multi-step tasks, how it reasons through code.

The practical takeaway: if you use OpenAI models in ChatGPT, in Codex or through the API, the model under your workflow has changed. Prompts that worked one way may now behave a little differently, often better, occasionally just differently. If you have AI features in production, this is when your test prompts earn their keep.

18 November: Gemini 3 and Antigravity

Google released Gemini 3 on 18 November, the next generation of its model family, and alongside it launched Antigravity, an agent-first development environment.

"Agent-first" is the interesting phrase. Most AI editors started as editors with AI added. As the name suggests, an agent-first environment flips that around: the agents doing the work are the main thing, and you supervise, review and steer them.

It's another sign of where the whole industry is heading. Claude Code, Codex, Gemini CLI, Cursor and Copilot have all been moving from "suggest the next line" toward "take this task and come back with a result". The tools differ, but the job of the developer in that world looks similar: write clear tasks, set up good guardrails, and review carefully.

20 November: PHP 8.5 and the pipe operator

For PHP developers, this is the headline of the month. PHP 8.5 was released on 20 November, and its most visible feature is the pipe operator, |>.

The pipe passes the value on its left into the callable on its right. That turns nested function calls, which you read from the inside out, into a chain you read from top to bottom:

// Before: read it inside out
$slug = strtolower(str_replace(' ', '-', trim($title)));

// PHP 8.5: read it top to bottom
$slug = $title
    |> trim(...)
    |> (fn (string $s) => str_replace(' ', '-', $s))
    |> strtolower(...);

A few things worth knowing before you start piping everything:

• Each step receives exactly one value. Functions that take a single argument can use first-class callable syntax like trim(...). Functions that need more arguments, like str_replace(), get wrapped in an arrow function.
• Arrow functions need parentheses inside a pipe chain, as in the example above.
• It's not a replacement for method chaining. Laravel's collections and the Str fluent helpers already read top to bottom. The pipe shines with plain PHP functions and your own small functions.
• Readability is the point. A two-step pipe is often less clear than one nested call. Use it where a chain of transformations genuinely reads better as steps.

The new URI extension

PHP 8.5 also adds a new URI extension for parsing and working with URLs according to the actual standards, RFC 3986 and the WHATWG URL specification used by browsers. For years, parse_url() has been the default tool, and it has quirks that don't always match how browsers and other systems interpret the same URL. If your app validates redirects, builds callback URLs or processes links from users, the new extension is worth a close look. It's the kind of feature that quietly removes a class of security bugs.

What I'd do this week

A busy month, and a familiar lesson

Three releases in nine days can feel like pressure to switch everything at once. You don't need to. The AI models will keep leapfrogging each other, and PHP 8.5 will still be there next month when your dependencies have caught up.

What's worth doing is making your setup ready for change: evaluation prompts for your AI features, a CI job that can test against a new PHP version, and instructions files that any agent can read. Then each new release is an afternoon of testing instead of a leap of faith.

Which of these are you trying first? And for the PHP folks: where would you actually use the pipe operator in your codebase?