Short Links, Big Impact: Automating Social Distribution with .NET and GenAI

We’ve all built a link shortener to learn a new language, but in the age of GenAI and Cloud-native orchestration, a simple redirect isn't enough. What if your link shortener didn't just shorten a URL, but understood its content, crafted a tailored social media campaign, and scheduled the posts automatically?

In this session, we take the classic "Link Shortener" project and supercharge it using the modern .NET stack. We will walk through the journey of building a Social Distribution Engine, a project that serves as the perfect playground for mastering Aspire, Azure OpenAI, and background service orchestration.

We’ll dive deep into the technical architecture, including:

The Intelligent Pipeline: Using Azure OpenAI to scrape destination content, summarize key takeaways, and generate platform-specific social media copy (X, LinkedIn, Mastodon).

Cloud-Native Orchestration: How Aspire simplifies the "wiring" of our web frontend, Redis cache, and background worker services without a single manual connection string.

Scheduled Execution: Implementing reliable background processing to handle rate-limiting and auto-scheduling for social API broadcasts.

Observability by Default: Leveraging the Aspire dashboard to trace an incoming link through the AI generation process to a successful social post.

This isn't just a "how-to" on link shortening; it’s a masterclass in using .NET to build integrated, AI-driven workflows that solve real-world productivity gaps.

I Let an Agent Migrate a .NET Framework App. Here's the Bill.

I've been giving talks about getting apps off .NET Framework for a long time. Lately the approach I've been teaching is to go piece by piece, with YARP in front of the old app, so you can move one part at a time and keep shipping.

A lot has changed. The promise now is that an agent can do a lot of the migration for you. So I'm letting one do it and writing down what it costs.

I'm starting with a sample, that covers Web Forms, MVC and a WinForms app that talks to WCF. Before the agent touches anything, I'm writing characterization tests so we know what working looks like. Then the agent migrates while I supervise and log the hours, the tokens, every time I have to step in, and everything that breaks along the way. I'm keeping a close eye on the usual suspects, like WCF, System.Web, config transforms and all that static state.

Together we will put the agent's version next to the piece-by-piece YARP approach and compare cost and risk. What I really want to know is how far the agent gets on its own, and what the last 20 percent costs. You'll leave with a realistic idea of what to hand an agent on your own migration, and what to keep for yourself.

180 Conversations: What Six Years of Interviewing Developers Taught Me

Since 2020 I've hosted Coffee and Open Source, a podcast and live stream where I talk with folks from across the tech industry. That's more than 180 episodes so far, which is a lot of yapping.

Now I'm going back through the whole archive and treating it like data. I'm tagging every episode for the themes that come up, like how people got started in open source, how they found contributors, burnout and career changes. Then I'm counting, and looking at what changed between 2020 and now. How often did AI come up in 2020, compared to this year? I'll have the numbers.

I'm especially interested in the setbacks, and how people came back from them. You'll hear those from the guests themselves, in short clips and quotes used with their permission.

There's no code in this one, just what six years of developer stories add up to, in their own words and with real numbers behind it.

Build a .NET TUI in 30 Minutes

Command-line tools are quick to create, but they often become difficult to use once a workflow requires multiple inputs, validation, progress updates, and meaningful results. A terminal UI provides structure and guidance without the deployment, hosting, and maintenance overhead of a web application—making it a practical fit for developer tools, internal utilities, deployment helpers, and AI-assisted workflows.

In this live build, we’ll turn a basic .NET console app into a maintainable TUI. You’ll learn how to:

- Guide users with prompts, selections, and validation
- Display tables, panels, and progress feedback
- Separate presentation from application logic
- Test workflows without fragile terminal automation
- Use Aspire integration for observability and diagnostics

You’ll leave with a reusable structure for building tools that are easier to operate, safer than ad hoc scripts, and simpler to support when something goes wrong.

I Automated My Podcast. Guess What Happened?

Every Coffee and Open Source episode comes with the same pile of chores. Stage the guest on the website, write a bio, track down the Spotify, Apple and Amazon links, then publish. Being the lazy developer I am, I handed those chores to an agent, with some pretty strict rules. Don't invent facts. Show me the diff and stop. Only use a link if it's an exact match.

Then it staged the guest with the bio of a completely different person with the same name. In its defense, it didn't make anything up. It found a real person, just the wrong one. I caught it before the episode was published (sorry, other person), and it got me thinking about where a human actually needs to be in the loop.

On my site, one commit publishes an episode and posts it to social media, so when the coding agent publishes one, it opens a pull request and I'm the one who merges it. The .NET dashboard I built to prepare episodes can't post or push anything, and every preview needs its own approval, tied to a hash of what I reviewed. The app I'm building to stream the show won't go live until I type GO LIVE.

In this session we will go through the real skills and approval gates, mistakes included. You'll see the difference between a rule an agent is asked to follow and a gate it can't get around, and why I'd take a tool that fails loudly over one that quietly fakes a step.

Everything in it runs on my own podcast tooling, and the website repo is public at https://github.com/isaacrlevin/CoffeeAndOpenSource.com.

Does Your Coding Agent Need an IDE? Semantic Code Tools vs. grep in .NET

A lot of coding agents find their way around a codebase with text search and a shell. Meanwhile the IDE sitting right next to them already knows every caller of every method, and it can rename a symbol across a whole solution without touching the wrong thing. Some tools can now hand that to an agent over MCP, so I wanted to know if it actually helps, and by how much. To be honest, I don't know yet.

I'm running the same .NET tasks three ways. One agent only gets file search and the shell. Another gets IDE tools over MCP. The third gets an open-source setup built on a language server, so anyone can reproduce it without a license. The tasks are the kind text search struggles with, like a rename across a solution, a signature change with a lot of callers, and a bug that only shows up in one test. For every run I'm tracking tokens, time, whether it worked, and how often the build broke along the way.

By the end you'll know which kinds of tasks are worth wiring up semantic tools for, and how to set them up for your own agent. You'll also get the harness, so you can run the same comparison on your own code.