As the United States celebrates its 250th anniversary, this special episode of Mailin’ It! explores how the country’s history has been documented for over a century in the corner of envelopes. Hosts Karla Kirby and Jeff Marino are joined by Smithsonian National Postal Museum Curator of Philately Daniel Piazza to examine how U.S. postage has evolved from simple delivery receipts into a "miniature scrapbook" that reflects American culture. Listeners will uncover the stories behind the stamps that have chronicled the American experience, from the 1865 Abraham Lincoln mourning stamp to an Apollo 11 master die that traveled to the moon in 1969, revealing how these miniature works of art have preserved the people, events, and achievements that shaped our country. Taken together, they map the story of a nation and reveal how its identity has evolved over time.
Hosted by Simplecast, an AdsWizz company. See pcm.adswizz.com for information about our collection and use of personal data for advertising.
Everybody loves AI until the invoice shows up! Not the cute "we spent a few hundred dollars experimenting" invoice that gets hand-waved away as innovation spend. I mean the kind of invoice that makes finance suddenly become deeply curious about architecture decisions they previously considered engineering trivia, while product teams insist everything is still technically a pilot, and leadership starts asking whether we can "optimize this" as though that thought had just occurred to humanity....
The speed that AI can now discover and exploit vulnerabilities means that our defenses also need to adjust. For the devices that you manage where you can afford to tighten deployment timelines, we'll explain updated recommendations and show you how to speed up patching.
It starts with assessing your risk exposure for unpatched devices using the new Autopatch report in Microsoft Intune, then tightening deferral policies on the devices where it makes sense, using Hotpatch to activate protection on install — without requiring reboots. Windows Autopatch automates your update deployments using rings to progressively apply updates to the device groups that you help define, including updates for Windows, Microsoft 365 Apps and the Edge browser. And to keep internal resources protected, you can enforce access controls using Conditional Access to block non-compliant devices.
Jeremy Chapman, Microsoft 365 Director, shares what's changed along with the approaches you can take to help counter the growing number of AI-discovered vulnerabilities and stay protected.
► QUICK LINKS: 00:00 - AI and Windows patch management 01:13 - Updated patching deferral thresholds 01:46 - Hotpatch on by default 02:05 - Windows Autopatch report 02:30 - Ring-based deployment + M365 Apps servicing profile 02:50 - Conditional Access for non-compliant devices 03:16 - Wrap up
► Unfamiliar with Microsoft Mechanics? As Microsoft's official video series for IT, you can watch and share valuable content and demos of current and upcoming tech from the people who build it at Microsoft.
As the share of code written by AI agents grows rapidly, two questions are central to effective AI adoption: How can teams turn AI usage into real productivity gains, and how can they maintain quality, security, and control while doing so? CI/CD is critical to both.
Every contribution, whether written by a human or an AI agent, still needs to be built, tested, verified, and delivered through a trusted process. With the volume of AI-generated code ever increasing and the need to verify its quality and security, CI/CD has to support this process at a new scale.
The context and tools that CI/CD provides to AI agents will determine how effectively they can work with verification results, react to failures, and iterate on changes. This will help teams improve velocity with AI while controlling quality, security, and delivery.
For many years, TeamCity has served as a CI/CD platform for reliable building, testing, and delivery in human-driven software development. We are now developing TeamCity for a new reality where software is created through the collaboration between humans and AI coding agents.
This evolution builds on TeamCity’s existing strengths: a powerful, flexible product foundation that enables scale from individual use to enterprise-level systems. We are investing in strengthening these foundations so TeamCity can reliably support higher code change volumes from developers and AI agents.
We’re also building new end-user scenarios that help teams maintain a smooth experience as software development processes evolve.
TeamCity today
TeamCity currently has four key strengths as a CI/CD platform:
Low-friction build configuration for any use case. UI, CLI, and AI-based configuration; pipelines in familiar YAML or the more flexible Kotlin DSL; multi-repository projects; build chains and dependencies; reusable templates; project hierarchy; and granular permissions.
Faster investigation and resolution of build failures. Automatic build problem detection; test history; structured build logs; visual pipeline overview; AI Assistant with build failure analysis; build agent terminal access for debugging failed builds directly on a remote machine; and working with builds from JetBrains IDEs without switching context.
Reduced build time and more efficient resource usage. Build reuse; caching; unlimited build chains; build agent pools and requirements; cloud profiles; and on-demand build agents to reduce repeated work, scale build capacity, and keep infrastructure usage under control.
Clear visibility across builds, tests, and the entire CI/CD system. Advanced test insights and history; build, change, and build queue overviews; investigation capabilities; custom report tabs; and deep build tool integrations for better build process observability.
We believe TeamCity is well-positioned for the evolution of CI/CD in a world with more code changes, more verification loops, more interaction between AI agents and CI/CD systems, and a stronger need for scale, reliability, and control.
TeamCity already supports scalability, optimization, and flexibility for complex pipelines. This helps you handle larger workloads and cover a wide variety of use cases. With AI agents, you can get your first builds up and running faster and navigate complex scenarios more easily.
TeamCity will also provide AI agents with relevant CI/CD context – such as test history, build results, and automatically detected build problems – so they can reason more quickly and accurately about failures and configuration changes. Tools such as pipeline debugging and terminal access can further help AI agents investigate issues and produce higher-quality fixes.
How we see CI/CD changing
AI adoption in development processes is growing. While many developers already use AI agents to write code, companies are still struggling to achieve large productivity gains at an organizational scale. JetBrains is committed to helping customers with this.
Part of the challenge is AI governance: security, cost control, and transparency around the use of AI agents in an organization. JetBrains addresses these problems with JetBrains Central – a new control plane for AI adoption in organizations.
As the use of AI agents in development increases, the requirements for CI/CD also evolve. In development processes where a lot of code is generated by AI agents, deterministic, reliable, and secure building, testing, and delivery become critical.
We see several key directions in which CI/CD tooling will evolve.
Scalability, performance, and flexibility. The load on CI/CD systems will grow as teams generate more code changes and run more verification checks for AI-generated code. Scalability and performance will play an important role, along with the flexibility of the systems to adapt to fast-changing use cases and rapid scaling inside organizations.
Interaction between AI agents and CI/CD tools. Both humans and AI agents will work with CI/CD systems through AI interfaces, such as CLI, MCP, and agent skills. They will use them for everyday CI/CD tasks like configuring and updating pipelines, running builds, checking results, investigating failures, and fixing build problems. The more context and tools a CI/CD platform can provide to AI agents, the faster, cheaper, and more accurately those agents can work.
Agentic steps in CI/CD. Some tasks within CI/CD workflows will be handled with AI tooling. CI/CD systems will need to support launching AI agents from builds and make it possible to configure these steps conveniently and securely.
AI governance. Both in-product AI features and AI agents launched from CI/CD steps will need to integrate with AI governance capabilities, giving organizations the control, visibility, and policy enforcement required to adopt AI safely.
How we’re developing TeamCity
We continue to develop TeamCity for this future, investing both in core CI/CD capabilities and in integration with AI workflows.
We’re taking a pragmatic approach to AI capabilities:
Investment in core CI/CD capabilities to ensure each customer’s desired level of determinism, scale, security, and human control.
Full support for development workflows across the whole spectrum of AI adoption – from fully human to autonomous AI processes.
Optional, governed, in-product AI features that solve end-user problems.
We are also deepening TeamCity’s role in the JetBrains ecosystem, which supports customers across the entire software development life cycle. JetBrains IDEs and Air help improve individual and team productivity, TeamCity builds and delivers code, Qodana helps ensure its quality, and JetBrains Central helps govern AI usage.
In line with this, the TeamCity roadmap is shaped around the following streams.
Enterprise-grade scalability, performance, and flexibility
We are investing in:
Performance and scalability. We are improving platform responsiveness and increasing throughput for code changes and code verifications.
Dynamic build chains. We aim to enable a more flexible approach to generating configurations during execution.
A faster and more familiar way to configure and work with builds. We are moving Pipelines – a new way to configure builds – from EAP to general availability, and we will continue developing them further. Pipelines bring native branch support, YAML alongside the Kotlin DSL, a visual drag-and-drop editor, easier access to powerful TeamCity features, and pipeline debugging, all while preserving the power and flexibility of TeamCity.
New and improved CI/CD integrations. We’re expanding support for popular tooling, including GitHub, build tools, SARIF, AWS, Azure, and more.
Developer experience and interfaces for AI agents
Our goal is to make it possible for developers to work with TeamCity end to end, both directly and through AI agents, without leaving their context, whether that’s the IDE, terminal, or an agentic development environment (ADE) like Air.
To do this, we are developing the CLI, MCP server, agent skills, and plugin for JetBrains IDEs. We are investing in support for working with TeamCity through these interfaces, including:
Pipeline configuration and migration from other CI/CD tools.
Build management, including working with statuses, investigations, and fixing failing builds.
Running builds, including runs without the commit-push cycle through remote runs from the IDE plugin.
Providing AI agents with data (build problems, test history, and more) that can help them work more cost-effectively and produce higher-quality results.
Support for AI build steps and AI governance
TeamCity can already launch AI agents as part of pipelines. We are expanding these capabilities and improving the user experience by:
Simplifying the setup of AI agent builds through easier configuration and ready-made recipes.
Bringing BYOK (Bring Your Own Key) to TeamCity, making it possible to use local LLMs or approved providers in TeamCity’s in-product AI features and AI workflows launched from TeamCity.
Integrating with JetBrains Central, a product that provides AI governance capabilities to help with AI adoption, including token quotas, analytics on token usage problems, and policies for LLM usage.
Longer-term plans
We continue to develop TeamCity in line with our vision of the future, while listening closely to our customers. We have set the main areas we are investing in while keeping the details flexible so we can adapt to customer needs, technology shifts, and broader market changes.
We want to highlight a few focus areas in our long-term plans:
Moving TeamCity toward proactive CI/CD, where it is an active participant in the development process, suggesting pipeline configurations and optimizations and using AI to help customers get more value with less friction.
Supporting merge trains and new VCS-related processes and tools that become relevant for AI-led development.
Strengthening continuous delivery capabilities to help teams ship AI-generated code faster while maintaining control.
Deepening integration with other JetBrains products, including JetBrains IDEs, JetBrains Central, and Air.
As AI changes how software is created, reliable and controlled building, testing, and delivery become even more important. That is the future we are building TeamCity for.
Learning identity management is hard enough. Navigating Okta’s documentation to build something shouldn’t be. If you’ve ever lost an afternoon stitching together how-to guides, product docs, and scattered blog posts just to figure out where to start, you’re not alone – and we’ve heard you, loudly and repeatedly.
Today, we’re excited to announce the official launch of Journeys: a new way to navigate Okta documentation built around the tasks you’re actually trying to accomplish.
What are Okta Journeys for developers?
A Journey is a curated, expert-driven, end-to-end guide built around a small-to-medium-sized development project. Rather than sending you to find a single document and piece the rest together yourself, each Journey walks you through the entire project, from foundational concepts to completion.
Journeys address the most frequent questions we’ve heard from developers. Every Journey includes both brand-new material and revised content to ensure that what you’re reading is accurate, up to date, and genuinely useful.
Each Journey organizes content into three main sections.
Learn identity foundations
Before you write a single line of code, it helps to know the terrain. The Learn section anchors the broad “identity” concept, covering foundational knowledge including Okta features, software development kits (SDKs), and application programming interfaces (APIs) relevant to your task. Whether you’re new to Okta or just unfamiliar with a specific area, this section gives you the vocabulary and mental model you need to make informed decisions. It ensures you’re not just following steps, but truly understanding the technology and concepts underlying your project.
Plan your customer identity implementation
Good implementations start with good planning. The Plan section walks you through the key decision points to consider before you begin – from the pros and cons of migration strategies and deployment models to configuration options, rate limits, and key performance indicators (KPIs). These are all common concerns from the field. Decisions made here shape everything that follows, so you won’t discover them for the first time mid-build.
Build and implement identity solutions
This is where everything comes together. The Build section presents a carefully curated collection of resources, organized to guide you through your project from start to finish. No more hunting across technical content channels to find the correct how-to guide, configuration advice, Knowledge Base (KB) article, blog post, API endpoint details, or videos. Everything you need is in one place, in the right order.
Every Journey covers the Okta-recommended approach and adds common alternatives when practical, because we know one size doesn’t always fit all.
Six Okta Journeys available now
The first six Journeys are live today, targeting Okta Customer Identity (OCI) builders developing and securing customer-facing portals. If you’re working on user authentication, registration, company branding, or user management, these Journeys are for you.
This is just the beginning. We’re already building new Journeys to tackle high-impact, emerging scenarios, including:
Okta for AI Agents: Detect, identify, manage, register, and govern your AI agents.
Building for the Okta Integration Network (OIN): Journeys for developers building different types of integrations for the Okta Integration Network.
Classic Engine to Okta Identity Engine Migration: Update your org to Okta Identity Engine and remove the Classic Engine-specific code from your apps.
We are committed to continuously expanding this library so that, no matter your development goal, you have a clear, expert-guided path to success.
Tell us what you think
These Journeys will fundamentally improve your development experience. Explore them, share your feedback, and let us know what Journeys you’d like to see next. Use the feedback tab on the Journey page, reach out to us on the Okta Developer Forums, or find us on socials.
Happy building.
Remember to follow us on X and subscribe to our YouTube channel and LinkedInfor more exciting content. We also want to hear from you about the topics you’d like to see and any questions you may have. Leave us a comment below!
Log in
