Enterprise AI solutions - intro

Most “build an AI agent” tutorials on blogs and YouTube live in a startup bubble: OpenAI, LangChain, deploy anywhere - your own VPS, whatever. Enterprise AI agents live somewhere else entirely. For an enterprise-ready solution you need reliability, security, governance and much more.

I’m a Cloudflare-first TypeScript dev with a Pega architect background. I’ve used Python and Azure before - touched them on past projects, shipped things that worked - but never went deep on either. Now I want to. The goal of this series is to stop treating them as tools I can get by with and start treating them as a stack I actually understand. In the current fast-changing world, experience with low-code tools might not be enough. You need to learn about agentic systems. If this sounds appealing, follow this tutorial.

From Cloudflare/TypeScript to Python on Azure - the stack shift this series is about.

This is Episode 1 of a ~6-part series. But the thing I want to open with isn’t Python, or the framework, or Azure. It’s how I’m going to learn them.

How I’m learning: Claude Code as a personalized tutor

I’m not opening a Python book. I’m not sitting through a 14-hour Udemy course. I’m building the app with Claude Code sitting next to me, and I’m turning it into a tutor that speaks my language - literally. I know exactly what I need to learn, but I wouldn’t find a combination of it in any training on the market. I will create my own.

The method has one foundation and three moving parts on top of it.

The foundation: a structured plan in Obsidian. Before I wrote a single line of Python, I built the whole journey as a 13-week bootcamp plan in an Obsidian vault - weekly tracks, per-week exit criteria, a glossary of every term I’d need to look up, and a dedicated analogies/ folder for TS↔Python and Cloudflare↔Azure mappings. The vault is the pillar everything else stands on. Without the plan, the Claude Code tutor would be aimless; with it, every chat has a place to land and a deadline behind it. I use these skills to give Claude Code a better understanding of Obsidian: https://github.com/kepano/obsidian-skills. More about skills later.

This is what CC built for me, the 14 tracks (T0 → T13):

• T0 - Prereqs and infra setup
• T1 - Python onramp for TS/JS devs
• T2 - Azure fundamentals and first deploy
• T3 - Azure OpenAI + Agent Framework hello world
• T4 - AI Foundry + Copilot Studio intro
• T5 - Python pro-code (FastAPI + testing)
• T6 - Azure security, observability, CI/CD
• T7 - Agent Framework depth (orchestration + MCP)
• T8 - RAG + evaluations
• T9 - Portfolio project: core build
• T10 - Portfolio project: enterprise features
• T11 - Frontend + Copilot Studio
• T12 - AI-102 cert prep
• T13 - Exams, close

The vault, as it actually is. T0–T13 weekly tracks plus the glossary, analogies, certifications, and resources folders that wrap around them.

The three moving parts on top:

1. Build first, understand second. Claude Code writes the Python. I review it line by line. When I hit something I don’t understand - a decorator, async def, Depends(), a ContextVar, a dunder method - I stop and ask Claude Code to explain it in terms of what I already know.

2. Analogy-driven explanations. My brain is wired for TypeScript, Hono, Cloudflare Workers, and (further back) Pega rule types. So I ask: “explain FastAPI dependencies like Hono middleware”, “compare pydantic to zod”, “is @tool just a decorator that returns a wrapper, like a higher-order function in TS?”, “map pytest fixtures to Vitest setup hooks”. The answers stick because they’re anchored to something real in my head, not floating in abstract “Python concepts” space. The good ones get distilled back into the vault’s analogies/ folder so they outlive the chat session.

3. Skills as reusable teaching prompts. Claude Code supports skills - small markdown files that extend its behavior for a specific task. I’m collecting mine from upstream sources, organized by domain:

• Python language, from microsoft/agent-framework:

  • python-development - coding standards and conventions
  • python-package-management - uv workflows
  • python-code-quality - linting and formatting rules

• Python tooling, from wshobson/agents:

  • python-testing-patterns - pytest, fixtures, TDD
  • python-performance-optimization - profiling and bottlenecks

• MCP servers, from github/awesome-copilot:

  • python-mcp-server-generator - scaffold a Python MCP server

• Azure, from microsoft/azure-skills:

  • azure-prepare → azure-validate → azure-deploy - the deployment pipeline
  • azure-ai - AI Search, Speech, OpenAI, Doc Intelligence
  • azure-compute - VM/VMSS routing
  • azure-diagnostics - production debugging

• Microsoft Agent Framework, from github/awesome-copilot:

  • microsoft-agent-framework - agents, workflows, migrations

• Dataverse, from github/awesome-copilot:

  • dataverse-python-quickstart - SDK setup + CRUD snippets
  • dataverse-python-production-code - production patterns
  • dataverse-python-advanced-patterns - error handling, optimization

• Meta skills, from mattpocock/skills - they are brilliant, I use them, everywhere:

  • domain-dictionary - DDD-style glossary extractor (terms I keep tripping on)
  • grill-me - forces Claude Code to interrogate me before agreeing with my plan

The skills make the tutor mine - every chat about Azure deployment or pytest already knows my house rules.

The actual skills folder. Domain-organized - Azure ops on top, Python on the bottom, framework- and Dataverse-specific in the middle, plus meta helpers like grill-me and domain-dictionary.

Why this beats a course - hopefully

Courses are good at walking the median path through a topic. They’re less good when you already know parts of the material from a different angle and want to skip ahead - or when you hit a gap the course assumed you didn’t have. A personalized tutor calibrates around what you actually know, and Claude Code does that on demand, sitting next to the code you’re writing.

The other thing a course doesn’t give you is your code to learn from. Every abstraction here is load-bearing on something I care about - the agent loop, the auth scope, the Azure deploy. No toy examples, no “imagine a blog with posts and comments.” The mental model builds on top of the app I’m actually shipping.

What I’m building

A minimal AI agent app that chats with tools (list / create / complete your tasks). Python + Microsoft Agent Framework on the backend, React + CopilotKit on the frontend, running on Azure App Service F1.

Why Agent Framework specifically? Microsoft offers more than one path to building an agent - Agent Framework (the pro-code Python/.NET SDK), AI Foundry’s agent service (managed runtime, designer-driven), and Copilot Studio (low-code, configurable by business users or partner consultants). Starting with Agent Framework gives me the deepest mental model of what an agent actually does under the hood. Later in the series I’ll get hands-on with Foundry and Copilot Studio so the “when each is the right call” judgment comes from feeling the trade-offs, not from reading docs.

What I like in MS Agent Framework is the workflows, which I know from Pega. Similar concept, this time in code and not via low-code configuration.

What I want to come out knowing

Past the artefact, four things I want to be fluent in by the end of this series (I’ll probably add to the list as I go):

• Python - not “I can read it” but “I can ship a production backend in it.” async, FastAPI, pytest, packaging, the 2026 type system as it actually exists.
• Azure and cloud services - App Service, Container Apps, Azure Files, Key Vault, Entra, the bits that show up in every enterprise diagram. I know Cloudflare Workers cold; I’ve barely opened the Azure portal in anger.
• Microsoft Agent Framework - how to use it well. Building agents, tool calling, orchestration, observability. When the framework’s abstraction helps and when you reach past it.
• Foundry vs Copilot Studio - when to reach for which. This is the real judgment call. Foundry is the pro-code path for building agents from scratch; Copilot Studio is the low-code surface where business users (or partner consultants) configure them. Knowing both isn’t the goal - knowing which to reach for in a given enterprise context is.

Those four targets are also why the bootcamp plan in the vault is structured the way it is - every weekly track maps back to one of them.

Why this stack (and not the obvious alternatives)

Three choices that will raise eyebrows:

• Python, not TypeScript - Microsoft Agent Framework lives here. The enterprise AI ecosystem lives here. I want to understand why. Additionally, knowing Python better helps me with ML tasks. Not all libraries are ported to TS.
• Azure App Service F1, not Container Apps - free tier, one-box, enough to ship a demo. Not enough for production; the upgrade path is the interesting content later.
• OpenAI direct, not Azure OpenAI - to stay on the free tier, I’ll use other providers to reach LLMs.

Each of these has a better enterprise answer. I’m picking the ones that let me ship and learn fast.

The roadmap (or lack of one)

I’m not pre-committing to specific episodes. The vault has a 13-week plan; the blog has a target of roughly six posts; what gets written - and in what order - is going to fall out of the work as I do it.

Topics I expect to hit eventually:

• A Python dev stack that finally feels nice for a JS dev (uv, ruff, just, FastAPI).
• A first Microsoft Agent Framework agent - @tool, the streaming shape, the AG-UI protocol.
• Wiring CopilotKit to a Python agent without their runtime.
• Scoping agent tools to the authenticated user - the bit enterprise tutorials skip.
• Deploying to Azure App Service F1 - Oryx, gunicorn, persistence.
• Foundry vs Copilot Studio - the judgment call I’m trying to learn.

Order: whatever I learn next that’s worth writing down. Running thread across all of them: the Claude Code skills and Obsidian notes I’m building as I go. The tutor grows with the app.

Who this is for

If you build AI agents for enterprise contexts - Microsoft, Salesforce, ServiceNow, Pega stack - this is for you. If you’re a JS/TS dev curious whether Python + FastAPI is worth the context switch, this is for you. If you’re learning anything unfamiliar and want to steal the “build + analogy + skill” method, this is especially for you.

Next post lands when there’s something real to say about it. Feedback welcome.