This episode marks the 11th anniversary of the show, and I want to celebrate by continuing our Career Growth Accelerator series. Today, we’re moving beyond the "autopilot" mode that many engineers find themselves in and learning how to define goals that are uniquely yours so you can find the specific challenges that will actually move the needle.

🎧 Episode Notes: Going from Autopilot to Purpose

Many of us operate on instinct, chasing goals like "get a promotion" or "make more money" without understanding the "why" behind them. This episode is designed to help you interrogate those automatic responses and find a path that is optimized for what you uniquely value.

• Break the Autopilot Loop: Understand why common goals like "getting a promotion" are often just survival mechanisms intended to keep us safe within social norms rather than reflections of our true values.
• The "Never Again" Pressure Test: Use the mental exercise of imagining you will never get another promotion; if this causes visceral anxiety, it’s a sign that your goal is rooted in a sense of safety rather than self-actualisation.
• Move from Post-Rationalisation to Purpose: Instead of backwards-justifying the status quo, learn to be honest about what you truly desire—whether it's the affirmation of intelligence, the freedom of discretionary time, or a specific mission.
• Create Instructive Goals: Discover why a goal must be personal and specific to be useful; a generic goal provides no roadmap, whereas a unique goal acts as an instruction for what to do next.
• Find Your True Challenge: Once your goal is defined, identify the specific obstacle standing in your way that requires ingenuity and isn't already decided for you.
• The "Asterisk" of Solvability: Learn the most critical rule for picking a challenge: it must be something you can reasonably solve given your current means to avoid falling back into paralysis and autopilot.

📮 Ask a Question

If you enjoyed this episode and would like me to discuss a question that you have on the show, drop it over at: developertea.com/contact

📮 Join the Discord

Join our supportive community of engineers working to improve their lives and careers at https://developertea.com/discord.

🧡 Leave a Review

If you're enjoying the show, head over to iTunes and leave a review! It helps other developers discover the show.

In this episode of Betatalks the Podcast, Rick and Oscar talk with Anjuli Jhakry, a .NET MAUI developer at 4Dotnet and Microsoft MVP who is building a startup app for people with food intolerances. She reflects on her move from Xamarin.Forms to .NET MAUI, noting how .NET 8 made the framework stable enough for production use. She explains how her app uses ML.NET to learn from user feedback and generate personalized dietary recommendations. They also highlight her rapid growth as a conference speaker and the importance of mentorship, the tech community, and keeping technical architectures simple. 

About this episode, and Anjuli Jhakry in particular: you can find Anjuli on LinkedIn.

About Betatalks: watch our videos and follow us on Instagram, LinkedIn, and Bluesky. 

Today I'm going to reflect back on 2025, highlight some things and project forward into 2026. I think there are some very important developments and changes that we all shipping custom software need to be on top of.

Want to Learn More? Visit AzureDevOps.Show for show notes and additional episodes.

This article is part of the Prompt Driven Development series from the VS Code YouTube channel. It is based on the video Introduction to Prompt Driven Development and explains the concepts and workflows demonstrated, with a focus on how prompt driven development can be applied in practice using Visual Studio Code and GitHub Copilot.

🎥 Video Reference

As AI tools become increasingly capable, developers are not only writing code differently but also rethinking how software is designed and built.

Terms such as vibe coding, prompt engineering, and prompt driven development are often used interchangeably. However, they represent distinct levels of structure, intent, and repeatability. Understanding these differences is essential to choosing the right approach for exploration, learning, or production ready systems.

This article explains these approaches and then highlights the key technical learnings demonstrated in the video.

🧠 Coding Styles in the Age of AI

✨ Vibe Coding

Vibe coding refers to an intuitive and exploratory way of working with AI. Developers rely on natural language prompts and personal intuition, allowing the AI to generate code based on intent rather than explicit structure.

This style is fast, creative, and useful for experimentation, but it often produces results that are hard to reproduce or maintain. Because prompts are informal and rarely documented, consistency becomes a challenge.

🎯 Prompt Engineering

Prompt engineering introduces intention and structure. Developers design prompts carefully to guide the AI toward specific and predictable outcomes.

This approach improves reliability and reduces randomness. However, prompts are still often treated as one off inputs, used once and discarded, rather than as reusable artifacts.

Prompt Driven Development

Prompt driven development treats prompts as first class technical artifacts.

In this approach, prompts are:

• Written intentionally
• Refined and iterated over time
• Documented and versioned
• Used to guide workflows, not just outputs

Rather than interacting with AI in isolated moments, developers design processes where prompts support planning, implementation, and iteration in a repeatable way.

📌 Five Key Learnings from the Video

1️⃣ Prompts Are Part of the Codebase

One of the main ideas demonstrated is that prompts should not be ephemeral. When prompts are saved, documented, and versioned, they capture architectural intent and decision making, just like code or design documents.

Using Markdown files inside the repository makes this process lightweight and easy to share.

2️⃣ Re Prompting Is an Expected and Valuable Practice

The video clearly shows that the first prompt is rarely sufficient.

Prompt driven development assumes iteration. Prompts improve through feedback, refinement, and clarification. This process is similar to refactoring code and should be treated with the same discipline.

Re prompting is not a failure. It is part of the workflow.

3️⃣ Documentation Can Drive Implementation

Instead of treating documentation as an afterthought, the workflow demonstrated uses documentation as the starting point for implementation.

By referencing a structured Markdown document, the AI can scaffold an application more consistently, reducing improvisation and making the process easier to reproduce.

4️⃣ AI Assisted Development Still Requires Validation

Even with AI generating code, traditional engineering practices remain essential.

The video reinforces the habit of:

• Installing dependencies locally
• Running and testing the application
• Reviewing behavior before committing changes

Prompt driven development enhances productivity, but it does not replace testing or validation.

5️⃣ Context Improves AI Output

Providing richer context leads to better results. The video demonstrates this through:

• Custom Chat Modes, which define purpose and output expectations
• Copilot Vision, which uses screenshots to reason about UI changes

By narrowing context and constraints, developers can guide AI systems more effectively and reduce ambiguity.

🛠️ Applying These Ideas in Practice

The workflow shown in the video combines several VS Code features to support prompt driven development:

• GitHub Copilot for ideation and implementation
• Markdown files for prompt documentation
• Custom Chat Modes for repeatable workflows
• Copilot Vision for context aware UI changes

Together, these tools help transform AI interactions into a structured and intentional development process.

Conclusion

Prompt driven development offers a practical way to integrate AI into software engineering without sacrificing rigor.

By treating prompts as structured, reusable artifacts, developers gain:

• Clearer workflows
• Better documentation
• More consistent outcomes
• Easier collaboration

For teams and individuals looking to move beyond ad hoc AI usage, prompt driven development provides a scalable and repeatable model grounded in existing engineering best practices.

The post shows how to set the correct amr value when authenticating using ASP.NET Core Identity and passkeys in .NET 10. When authenticating using OpenID Connect and passkeys authentication, the OpenID Connect Extended Authentication Profile (EAP) ACR Values 1.0 specification should be used for the implementation. The amr claim should return the pop value.

Blogs in this series:

• Digital authentication and identity validation
• Set the amr claim when using passkeys authentication in ASP.NET Core

Setup

A typical web application would authenticate using OpenID Connect with client assertions and OAuth PAR. When the user authenticates, passkeys are used for the user authentication. The server returns claims to the client application and the amr claim is returned with the “pop” value.

Specifications

The following two specifications are used as the basis for the implementation.

• OpenID Connect Extended Authentication Profile (EAP) ACR Values 1.0
• RFC 8176 Authentication Method Reference Values

Set the amr value

The amr claim is set after a successful passkey authentication. At present, this is not implemented correctly in ASP.NET Core (.NET 10) and the amr claim needs to be set. The User.Claims array is immutable and so needs to be re-created.

result = await _signInManager.PasskeySignInAsync(
       Input.Passkey.CredentialJson);

if (result.Succeeded)
{
    user = await _userManager.GetUserAsync(User);

    // Sign out first to clear the existing cookie
    await _signInManager.SignOutAsync();

    // Create additional claims
    var additionalClaims = new List<Claim>
    {
        new Claim(Consts.LOA, Consts.LOA_400),
        new Claim(Consts.LOI, Consts.LOI_100),
        // ASP.NET Core bug workaround:
        // https://github.com/dotnet/aspnetcore/issues/64881
        new Claim(JwtClaimTypes.AuthenticationMethod, Amr.Pop)
    };

    // Sign in again with the additional claims
    await _signInManager.SignInWithClaimsAsync(
          user!, isPersistent: false, additionalClaims);
}

See the github issue about ASP.NET Core and the amr:

https://github.com/dotnet/aspnetcore/issues/64881

The web application displays the correct claims after a passkey authentication.

Force phishing resistant authentication

Using the specification “OpenID Connect Extended Authentication Profile (EAP) ACR Values 1.0”, the OpenID Connect client can force a phishing resistant authentication by setting the acr_values to “phr” or “phrh“. This would need to be supported on the OpenID Connect server.

The client would send the request using the OnRedirectToIdentityProvider method

OnRedirectToIdentityProvider = async context =>
{
    // Require passkeys
    context.ProtocolMessage.AcrValues = "phr";
 
    await Task.CompletedTask;
}

Or when using OAuth PAR, using the OnPushAuthorization method :

OnPushAuthorization = context =>
{
    // https://openid.net/specs/openid-connect-eap-acr-values-1_0-final.html
    context.ProtocolMessage.AcrValues = "phr";

    return Task.FromResult(0);
},

Examples of OpenID Connect server implementations:

• https://duendesoftware.com/blog/20250708-step-up-challenges-with-duende-identityserver-and-aspnet-core-apis
• https://damienbod.com/2025/07/02/implement-asp-net-core-openid-connect-with-keykloak-to-implement-level-of-authentication-loa-requirements/

Links

https://github.com/dotnet/aspnetcore/issues/64881

https://openid.net/specs/openid-connect-eap-acr-values-1_0-final.html

https://datatracker.ietf.org/doc/html/rfc8176

https://learn.microsoft.com/en-us/aspnet/core/security/authentication/claims

Google recently published a guide outlining eight essential design patterns for multi-agent systems, ranging from sequential pipelines to human-in-the-loop architecture. The guide provides concrete explanations of each pattern along with sample code for Google's Agent Development Kit.