Push-Based

🚀 𝗙𝗮𝘀𝘁𝗲𝗿 𝗿𝗲𝗹𝗲𝗮𝘀𝗲𝘀 𝗱𝗼𝗻'𝘁 𝗮𝗹𝘄𝗮𝘆𝘀 𝗺𝗲𝗮𝗻 𝗳𝗮𝘀𝘁𝗲𝗿 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝘀.

Most engineering leaders invest heavily in improving developer productivity—and rightly so. Faster build pipelines mean quicker feedback loops, shorter release cycles, and lower engineering costs.

⚠️ But there's a hidden trade-off.

Some build optimizations can unintentionally increase the work the browser has to do, slowing down the experience for your users. That means the gains inside your engineering organization can come at the expense of customer experience.

📊 In our research, we found that a build configuration optimized for speed nearly 𝗱𝗼𝘂𝗯𝗹𝗲𝗱 𝗽𝗮𝗴𝗲 𝗹𝗼𝗮𝗱 𝘁𝗶𝗺𝗲 in a real-world scenario—without adding more application code.

💡 𝗧𝗵𝗲 𝗹𝗲𝘀𝘀𝗼𝗻?

Engineering productivity and runtime performance should be treated as complementary business metrics—not competing priorities.

Our latest article explains where this trade-off comes from, how to identify it in your applications, and how to optimize for both developer velocity and user experience.

🔗 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗮𝗿𝘁𝗶𝗰𝗹𝗲: https://push-based.io/article/faster-builds-slower-applications-optimizing-angulars-bundle-output

⚡ 𝗙𝗮𝘀𝘁 𝗯𝘂𝗶𝗹𝗱𝘀 𝗱𝗼𝗻'𝘁 𝗮𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗰𝗮𝗹𝗹𝘆 𝗰𝗿𝗲𝗮𝘁𝗲 𝗳𝗮𝘀𝘁 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻𝘀.

's new build system is a huge win for developer productivity. Build times are dramatically faster, making the development experience better than ever.

But there's another side to the story.

In large applications, the new bundling strategy can produce hundreds of small chunks. While that helps the bundler optimize build speed, it can significantly increase the number of network requests during page load—and those requests still have a cost, even with HTTP/2 and HTTP/3.

In our tests, simply increasing the number of additional chunks from 𝗼 𝘁𝗼 𝟱𝟬𝟬 increased 𝗟𝗮𝗿𝗴𝗲𝘀𝘁 𝗖𝗼𝗻𝘁𝗲𝗻𝘁𝗳𝘂𝗹 𝗣𝗮𝗶𝗻𝘁 (𝗟𝗖𝗣) from 𝟮.𝟵𝟱 𝘀 𝘁𝗼 𝟱.𝟳𝟵 𝘀—without increasing the amount of or changing the rendered content.

That led us to a question:

𝗖𝗮𝗻 𝘄𝗲 𝗸𝗲𝗲𝗽 𝗘𝘀𝗯𝘂𝗶𝗹𝗱'𝘀 𝗶𝗻𝗰𝗿𝗲𝗱𝗶𝗯𝗹𝗲 𝗯𝘂𝗶𝗹𝗱 𝘀𝗽𝗲𝗲𝗱 𝘄𝗵𝗶𝗹𝗲 𝗽𝗿𝗼𝗱𝘂𝗰𝗶𝗻𝗴 𝗮 𝗯𝘂𝗻𝗱𝗹𝗲 𝘁𝗵𝗮𝘁'𝘀 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗱 𝗳𝗼𝗿 𝗿𝘂𝗻𝘁𝗶𝗺𝗲 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲?

In our latest article we explore:

✅ Why chunk count matters more than many developers realize
✅ Why Angular's new build system produces so many chunks
✅ Why HTTP/2 doesn't make requests "free"
✅ Reachability-based bundle optimization strategies
✅ How we built -angular/rebundle to optimize Angular production bundles

If you're working on a large Angular application, this is worth understanding.

🔗 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗳𝘂𝗹𝗹 𝗮𝗿𝘁𝗶𝗰𝗹𝗲: https://push-based.io/article/faster-builds-slower-applications-optimizing-angulars-bundle-output

𝗡𝘅 𝟮𝟯.𝟭 𝗶𝘀 𝗵𝗲𝗿𝗲 — 𝗮𝗻𝗱 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝟮𝟮 𝗱𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿𝘀 𝘀𝗵𝗼𝘂𝗹𝗱 𝘁𝗮𝗸𝗲 𝗻𝗼𝘁𝗲.

The latest Nx release brings first-class support for 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝟮𝟮, making upgrades smoother with updated generators, executors, and migrations.

But that's not all. A few other additions stand out—especially for teams working with large monorepos:

📊 𝗣𝗲𝗿-𝗥𝘂𝗻 𝗣𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 𝗥𝗲𝗽𝗼𝗿𝘁𝘀
Instead of only looking at aggregate CI metrics, Nx Cloud now lets you inspect individual pipeline runs. That makes it much easier to understand why a specific build was slow, identify cache misses, and spot bottlenecks.

🟦 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝟲 𝘀𝘂𝗽𝗽𝗼𝗿𝘁
Nx now officially supports TypeScript 6, helping teams adopt the latest compiler while staying compatible across the Nx ecosystem.

🛠️ 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗱 𝗺𝗶𝗴𝗿𝗮𝘁𝗶𝗼𝗻𝘀 & 𝗲𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺 𝘂𝗽𝗱𝗮𝘁𝗲𝘀
As expected from a .1 release, there are plenty of plugin updates, migration improvements, bug fixes, and compatibility enhancements to make upgrading less painful.

It's great to see the Nx team keeping pace with Angular releases while continuing to invest in developer productivity and CI observability.

If you're planning your Angular 22 upgrade, this release is definitely worth checking out.

🎥 Want a walkthrough of everything that's new? Juri Strumpflohner from the Nx team covers the highlights here:
https://www.youtube.com/watch?v=sDeptlEXD10

What feature are you most looking forward to using?

⚡ 𝗔𝗻𝗴𝘂𝗹𝗮𝗿 𝗶𝘀 𝗿𝗲𝗺𝗼𝘃𝗶𝗻𝗴 𝗺𝗼𝗿𝗲 𝗕𝗮𝗯𝗲𝗹 𝗳𝗿𝗼𝗺 𝘁𝗵𝗲 𝗖𝗟𝗜. ⚡

Another step towards a leaner and faster build pipeline.

An open Angular CLI PR replaces the remaining Babel-based production optimization plugins with a new transformation built on Oxc and Magic String.

What does that mean?

✅ Production builds can skip Babel for these optimization passes.
✅ Angular-specific optimizations are performed in a single transformation.
✅ Less parsing, less work, potentially faster builds—especially for larger applications and monorepos.

The new optimization pass handles things like:
• removing Angular development metadata
• optimizing TypeScript enum output
• annotating code for better tree shaking
• optimizing static class members

This isn't a flashy new feature you'll notice in your code editor.

It's something arguably more important: Angular continues investing in modern build infrastructure that makes every production build a little more efficient.

Over the past releases we've seen Angular embrace esbuild, Vite, incremental improvements to the CLI, and now another move away from legacy Babel transforms.

The trend is clear: less legacy tooling, more performance.

What do you think—should Angular continue replacing parts of its toolchain with newer projects like Oxc where it makes sense?

PR: https://github.com/angular/angular-cli/pull/33568

⚡ 𝟭𝟭𝟲 𝘀𝗲𝗰𝗼𝗻𝗱𝘀.
That was how long every Git hook took to run in one of our enterprise monorepos.
Not because the validations themselves were slow—but because years of tooling layers had quietly accumulated around them.

→ → .js → -staged → custom wrappers → finally... the actual validation.

So we asked a simple question:

𝗪𝗵𝗮𝘁 𝗶𝗳 𝘄𝗲 𝗿𝗲𝗺𝗼𝘃𝗲𝗱 𝘁𝗵𝗲 𝗼𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗶𝗼𝗻 𝗶𝗻𝘀𝘁𝗲𝗮𝗱 𝗼𝗳 𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗶𝗻𝗴 𝗶𝘁?

The result?
🚀 𝗚𝗶𝘁 𝗵𝗼𝗼𝗸 𝗿𝘂𝗻𝘁𝗶𝗺𝗲: 116.65s → 7.28s (16 x faster)
⚙️ 𝗨𝘀𝗲𝗿 𝗖𝗣𝗨 𝘁𝗶𝗺𝗲: 47 x lower
🧩 𝗖𝗼𝗻𝗳𝗶𝗴𝘂𝗿𝗮𝘁𝗶𝗼𝗻: Three systems replaced with a single declarative file.

In our latest case study, we walk through:
• why we migrated from Husky + lint-staged to
• how we approached the migration without disrupting developer workflows
• the performance benchmarks before and after
• the lessons we learned about developer tooling, orchestration overhead, and native binaries

Sometimes the biggest performance wins don't come from making code faster.

𝗧𝗵𝗲𝘆 𝗰𝗼𝗺𝗲 𝗳𝗿𝗼𝗺 𝗿𝗲𝗺𝗼𝘃𝗶𝗻𝗴 𝘂𝗻𝗻𝗲𝗰𝗲𝘀𝘀𝗮𝗿𝘆 𝗹𝗮𝘆𝗲𝗿𝘀.

📖 Read the full case study:
https://push-based.io/article/from-116-seconds-to-7-how-we-rebuilt-an-enterprise-git-hook-pipeline

🚀 TypeScript 7 just landed.

A few weeks ago, we shared that was rewriting the compiler in . Today, that work officially ships with TypeScript 7, bringing up to 10× faster compilation, parallel type checking and a dramatically improved developer experience.

There are no flashy language features. No revolutionary syntax.

Instead, Microsoft focused on something much more valuable: developer productivity.

Because developer productivity isn't only about writing code faster—it's about spending less time waiting.

TypeScript 7 brings:

⚡ Up to 10× faster compilation
🧵 Parallel type checking
📦 Parallel project builds
👀 A completely rewritten watch mode

For developers working in large repositories and monorepos, this could have a bigger impact than any new language feature.

Ironically, the biggest TypeScript release in years isn't about changing how we write TypeScript.

𝗜𝘁'𝘀 𝗮𝗯𝗼𝘂𝘁 𝗺𝗮𝗸𝗶𝗻𝗴 𝗧𝘆𝗽𝗲𝗦𝗰𝗿𝗶𝗽𝘁 𝗴𝗲𝘁 𝗼𝘂𝘁 𝗼𝗳 𝘁𝗵𝗲 𝘄𝗮𝘆.

⚠️ One important note for Angular developers: Angular won't adopt TypeScript 7 immediately because the new compiler API isn't ready yet. The TypeScript team expects a stable API in TypeScript 7.1, after which Angular and other frameworks can begin integrating the new compiler and unlock its performance benefits.

This is one of those releases where you probably won't write different code—but you'll spend a lot less time waiting for it to compile.

just released another open-weight coding model.
A few months ago, that headline alone would have been a big deal.
Today? It almost feels routine.

Every week there's another capable coding model. Another AI IDE. Another agent. Another benchmark claiming to be the new state of the art.

𝗪𝗲'𝗿𝗲 𝗿𝗲𝗮𝗰𝗵𝗶𝗻𝗴 𝗮 𝗽𝗼𝗶𝗻𝘁 𝘄𝗵𝗲𝗿𝗲 𝘁𝗵𝗲 𝗺𝗼𝗱𝗲𝗹 𝗶𝘁𝘀𝗲𝗹𝗳 𝗶𝘀 𝗻𝗼 𝗹𝗼𝗻𝗴𝗲𝗿 𝘁𝗵𝗲 𝗰𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗮𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲.

The real differentiator is everything around it:

✅ How you provide context
✅ How you orchestrate multiple agents
✅ How you evaluate outputs
✅ How you make workflows reproducible across an entire engineering team

A better model next month shouldn't require your developers to reinvent how they work.

𝗧𝗵𝗮𝘁'𝘀 𝘄𝗵𝘆 𝘄𝗲 𝗯𝗲𝗹𝗶𝗲𝘃𝗲 𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗶𝘀 𝗺𝘂𝗰𝗵 𝗯𝗶𝗴𝗴𝗲𝗿 𝘁𝗵𝗮𝗻 𝗺𝗼𝗱𝗲𝗹 𝘀𝗲𝗹𝗲𝗰𝘁𝗶𝗼𝗻.

The organizations that invest in deterministic workflows, reusable context, evaluation and governance will be able to adopt every new model as it appears—whether it's Poolside, Claude, GPT, Gemini or whatever comes next.

𝗧𝗵𝗲 𝘄𝗶𝗻𝗻𝗲𝗿𝘀 𝘄𝗼𝗻'𝘁 𝗯𝗲 𝘁𝗵𝗲 𝘁𝗲𝗮𝗺𝘀 𝘂𝘀𝗶𝗻𝗴 𝘁𝗵𝗲 "𝗯𝗲𝘀𝘁" 𝗺𝗼𝗱𝗲𝗹.
𝗧𝗵𝗲𝘆'𝗹𝗹 𝗯𝗲 𝘁𝗵𝗲 𝘁𝗲𝗮𝗺𝘀 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗯𝗲𝘀𝘁 𝗔𝗜 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗽𝗿𝗼𝗰𝗲𝘀𝘀.

𝗧𝗵𝗶𝘀 𝘀𝗵𝗶𝗳𝘁 𝗶𝘀 𝗲𝘅𝗮𝗰𝘁𝗹𝘆 𝘄𝗵𝘆 𝘄𝗲 𝗰𝗿𝗲𝗮𝘁𝗲𝗱 𝗼𝘂𝗿 𝗔𝗜-𝗔𝘀𝘀𝗶𝘀𝘁𝗲𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗺𝗲𝗻𝘁 𝗙𝗼𝘂𝗻𝗱𝗮𝘁𝗶𝗼𝗻𝘀 𝘄𝗼𝗿𝗸𝘀𝗵𝗼𝗽.
Because the future belongs to teams that can adopt any model—not just master one.
👉 https://push-based.io/workshop/ai-assisted-development-foundations

🍎 just filled an important gap in AI-assisted frontend development.

With the new MCP Server, AI coding agents can now inspect and debug applications running in Safari—not just generate code.

That may sound incremental, but it's actually a notable milestone.

We've already seen AI agents gain deep browser integration through Chrome DevTools and Playwright. Now Safari joins the party, giving agents access to the browser that's traditionally been one of the hardest to debug.

For frontend teams, this means AI can now:

✅ inspect the live DOM
✅ analyze console output and network requests
✅ verify visual rendering in Safari
✅ perform accessibility checks
✅ validate that fixes actually work

The bigger trend is even more interesting.

AI is no longer limited to generating code—it can increasingly verify its own work against the running application.

That's a fundamental shift.

Instead of asking an LLM, "Can you write this component?", we're moving toward, "Build it, test it in the browser, identify what's wrong, fix it, and prove the fix works."

Safari joining the MCP ecosystem is another step toward that future.

🔗 https://webkit.org/blog/18136/introducing-the-safari-mcp-server-for-web-developers/?b=1

🚀 𝗜𝘁'𝘀 𝗴𝗼 𝘁𝗶𝗺𝗲! Today marks the start of 𝗕𝘂𝗶𝗹𝗱 𝘄𝗶𝘁𝗵 𝗔𝗜 𝗪𝗿𝗼𝗰ł𝗮𝘄! 🎉

Over the next 𝟲 𝗱𝗮𝘆𝘀, developers, designers, DevOps engineers, and product builders will come together to do something special: build real AI-powered products from idea to production.

From product discovery and definition to deployment, optimization, and launch, participants will experience the entire software development lifecycle as one cross-functional team—with as a collaborative partner every step of the way.

We're proud to support this incredible initiative as a sponsor and to give back to the amazing Wrocław developer community. A special thank you to our colleague Adrian Romanski for organizing this event and helping make it a reality. 🙌

Together with 𝗝𝘂𝗹𝗶𝗮 𝗥𝗮𝗽𝗰𝘇𝘆𝗻𝘀𝗸𝗮, Adrian is also part of the fantastic group of mentors and Team Leads who will be supporting participants throughout the week.

Have an amazing week, everyone! We can't wait to see the ideas, products, and collaborations that come out of it. 🚀
🔗 https://gdg.community.dev/events/details/google-gdg-wroclaw-presents-build-with-ai-wroclaw-architecting-the-future-of-products/

🤖💙 What a fantastic day at Google I/O Connect Berlin!

A huge thank you to the entire team and everyone who made this event happen.

One of the best parts of the day wasn't just the announcements—it was catching up with so many incredible people from the developer community. It was great meeting fellow GDEs, reconnecting with familiar faces, making new connections, and having countless inspiring conversations about , , development, open source, and where our industry is heading.

These conversations are what make events like this so valuable. Sharing ideas, learning from each other, challenging perspectives, and leaving with fresh inspiration is something you simply can't replace.

And of course... not everyone spent the day networking with humans. 😄

Our colleague Adrian Romański even got to meet one of the Gemini Robotics demos running on a Unitree G1 humanoid robot. 🤖

Thanks to everyone we met yesterday. It's the people and the community that make events like Google I/O so special.

Already looking forward to the next one! 🚀