2026-01-23

• Show conversation compaction status as timeline messages instead of header indicator
• Memory loading no longer warns when outside a Git repository
• Add support for GHE Cloud (*.ghe.com) remote custom agents
• Plugin uninstall now works correctly
• Expose MCP server and tool names in tool.execution_start events for better error handling
• Add Esc-Esc to undo file changes to any previous snapshot

v1.24.10212.0

v1.23.20211.0

We’re in the middle of a transition period for the software industry.

Not just a new toolchain or another framework, but a shift in how we think about software: how it’s written, which paradigms we rely on,
and who the real “actors” in the system are.

We’ve lived through major paradigm shifts before:

• Monoliths to microservices
• Imperative to declarative programming
• On-premise infrastructure to cloud-native systems
• Server-centric systems to mobile-first applications
• Centralized backends to IoT and edge-driven architectures
• Manual operations to infrastructure as code

Each shift forced us to rewrite our mental models.

AI is no longer just assisting developers, it is actively producing, shaping, and evolving software through agentic workflows, spec-driven development, and reusable agent skills.

That reality forces us to rethink something fundamental:

What should a library look like when humans are no longer the only, or even the primary, consumer?

Libraries Were Built for Developers — Not for Agents

For years, libraries and packages were designed almost exclusively for developer experience.

We optimized for:

• Friendly APIs
• Fluent abstractions
• IntelliSense and discoverability
• Boilerplate reduction
• Familiar industry conventions

We spent enormous effort answering questions like:

• Should this be opinionated or flexible?
• What feels natural to developers?
• How do we reduce mistakes through API design?

And we were right to do so.

But something has changed.

Developers are no longer the only ones writing code.

From Prompting to Agentic Development

AI-assisted development evolved quickly:

• From simple prompting
• To inline suggestions
• To slash commands
• To autonomous agents
• To spec-driven development powered by agent skills

In these workflows, agents:

• Generate significant portions of code
• Make architectural decisions
• Adapt code to local standards
• Apply patterns repeatedly and consistently

At that point, agents become consumers of libraries.

And like in any other industry, when your customer changes, your product must evolve.

This is where Skills-Native Libraries enter the picture.

Skills-Native Libraries: The Missing Link

A Skills-Native Library is not just a package.

It is a combination of:

• A core library that provides real, durable value
• One or more agentic skills designed to use that library correctly

In practice, this means:

• The library encodes the hard, non-trivial logic
• The agent skill encodes best practices, patterns, and usage knowledge
• Together, they form a coherent unit that works naturally in agentic workflows

Skills-Native Libraries can exist in any ecosystem (e.g., npm, pip, NuGet).

What makes them “skills-native” is not the runtime — it’s the intentional pairing of library and agent skill.

Generative Agents Don’t Need Determinism, They Need Boundaries

Modern AI code agents are not deterministic systems.

They are probabilistic, generative models that excel at:

• Adapting to context
• Personalization
• Filling in gaps
• Working with incomplete specifications

But when the decision space is too wide, they can:

• Hallucinate behavior
• Infer incorrect assumptions
• Misuse APIs that look right
• Violate hidden invariants

The goal is not to constrain agents into rigid contracts.

The goal is to shape the problem space.

Skills-Native Libraries do exactly that:

• The library provides strong invariants and guardrails
• The agent skill guides usage within those boundaries
• Flexibility is preserved — but channeled

This is why agent skills and skills-native libraries are better together.

When Skills Replace Libraries and When They Don’t

In some simple cases, an agent skill might fully replace a library.

That’s fine.

But for non-trivial domains — event sourcing, consistency, concurrency, durability, data correctness, core logic belongs in a library.

The right model is:

• Libraries for durable, high-value, invariant-heavy logic
• Agent skills for usability, adaptation, and evolution

A well-designed Skills-Native Library might include:

• A strong core package
• A SKILL.md definition (governs tools, MCP, etc).

The Real Shift

The key shift is not: “AI replaces libraries”

The shift is:

Libraries and agentic skills are complementary primitives.

Together, they enable:

• Safer agentic development
• Faster iteration
• Better alignment with domain intent
• Less accidental complexity

Final Thought

Agentic development is not just about generating more code.

It’s about embedding knowledge into systems, some of it in libraries, some of it in skills.

Skills-Native Libraries are the foundation for better agentic results and faster dev cycles.

This week, we’re sharing powerful stories and hands-on code! The Angular community is defined by its willingness to share personal journeys, provide practical examples, and dive deep into major features like Signal Forms.

Check out these valuable resources from Angular experts:

• From ASP.NET to Angular: My MVP Story
  Sonu Kapoor @SonuKapoor1978 shares a compelling personal story about transitioning from the ASP.NET ecosystem to becoming an Angular expert and MVP. This is a great read for anyone navigating a career shift!
• Read the inspiring journey: https://techcommunity.microsoft.com/blog/mvp-blog/from-asp-net-to-angular-my-mvp-story---sonu-kapoor/4458699
• Angular Signal Forms (3-Part Series)
  Ferdinand Malcher @fmalcher01 & Danny Koppenhagen provide the definitive guide to mastering the new Signal Forms API in Angular! This three-part series offers everything you need to know about this major update to forms management.
  Part 1: https://angular-buch.com/blog/2025-10-signal-forms-part1
  Part 2: https://angular-buch.com/blog/2025-10-signal-forms-part2
  Part 3: https://angular-buch.com/blog/2025-10-signal-forms-part3
• Building AI-Powered Content with Angular and Gemini
  Ready to integrate AI into your apps? Babatunde Lamidi shares a complete code sample showing you exactly how to build an AI-powered content generator using Angular and the Gemini API.
  Explore the GitHub repo: https://github.com/babatundelmd/ng-content-generator
• Modernizing Angular Control Flow
  Antonio Cardenas @yeoudev provides essential real-world guidance and code examples for updating your applications to use Angular’s new, more efficient built-in Control Flow syntax.
  See the code sample: https://dev.to/turingsoracle/updating-to-angular-20-a-real-world-guide-2h9o

Have you integrated Signal Forms or the new Control Flow into your app yet? Share your experience or a snippet of your code!

Help grow the ecosystem! Use #AngularSparkles to share your favorite Angular resources.

Community Stories, Code Samples, and Signal Forms! 🌟 was originally published in Angular Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.