<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Kuldeep Chowhan ‘s Blog - Medium]]></title>
        <description><![CDATA[Blog of Proven Cloud Architect | Cloud Evangelist | Conference Speaker | Principal Engineer @ Expedia, Inc. - Medium]]></description>
        <link>https://medium.com/kuldeep?source=rss----b16783ca6932---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>Kuldeep Chowhan ‘s Blog - Medium</title>
            <link>https://medium.com/kuldeep?source=rss----b16783ca6932---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 12:35:12 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/kuldeep" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[AI Agents for Normal Builders: A Practical Guide to Getting Real Work Done]]></title>
            <link>https://medium.com/kuldeep/ai-agents-for-normal-builders-a-practical-guide-to-getting-real-work-done-781364a19f5b?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/781364a19f5b</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 09:58:43 GMT</pubDate>
            <atom:updated>2026-06-15T09:58:44.585Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1gg7rclTT7TdqiDbm5MSGA.jpeg" /></figure><p>AI agents are having a moment. Most of the conversation is either hype or doom. Neither helps you ship.</p><p>An AI agent is not magic. It is a workflow.</p><p>If you strip it down, an agent is simply: <strong>**LLM + tools + memory + a loop + guardrails.**</strong></p><p>When that combination is designed well, it compresses 30-to-90-minute tasks into 3-to-10 minutes of review. When designed poorly, it becomes a confident intern that breaks production.</p><p>This post is a practical guide for builders who want agents that do real work — with concrete examples using <a href="https://docs.anthropic.com/en/docs/claude-code">Claude Code</a>.</p><h4><strong>What an Agent Actually Is (In One Paragraph)</strong></h4><p>A chatbot answers prompts. An agent completes outcomes.</p><p>The difference is the loop:</p><p>1. Interpret the goal</p><p>2. Plan the steps</p><p>3. Take an action (call tools, read data, write output)</p><p>4. Observe the result</p><p>5. Correct and continue</p><p>6. Stop when success criteria are met</p><p>If your system cannot take actions and verify results, it is not an agent. It is autocomplete with extra steps.</p><p>Claude Code implements this loop natively. When you give it a task, it plans, calls tools (bash, file read/write, search), observes output, adjusts, and continues until done. That is why it works as both a practical coding tool and a reference architecture for how agents should behave.</p><h3><strong>The 4 Levels of Agent Maturity</strong></h3><p>Most teams skip levels and get burned. Start here.</p><h4><strong>Level 1: Assisted Drafting</strong></h4><p>The agent produces output, you paste it somewhere.</p><p><strong>**Examples:**</strong> write an email, summarize notes, generate a spec, draft SQL, create an outline.</p><p>When it works: low risk, high speed. Failure mode: none, because you are the executor.</p><p><strong>*Claude Code in practice — generating a spec:**</strong></p><pre>claude &quot;Read the codebase in ~/src/myapp and generate a technical spec<br>for adding rate limiting to the API layer. Include current architecture,<br>proposed changes, and migration steps.&quot;</pre><p>Claude Code reads your files, understands the architecture, and produces a spec you review. Level 1. No risk.</p><h4><strong>Level 2: Tool-Using Helper</strong></h4><p>The agent can call tools but cannot change important systems.</p><p><strong>**Examples:**</strong> search docs, query analytics, read logs, generate reports, propose Jira tickets.</p><p>When it works: research, analysis, triage. Failure mode: wrong interpretation of data. Fix with citations and verification.</p><p><strong>**Claude Code in practice — codebase analysis:**</strong></p><pre>claude &quot;Analyze the error handling patterns across this repo. Find<br>inconsistencies, missing error boundaries, and cases where we swallow<br>exceptions silently. Produce a prioritized list with file paths and<br>line numbers.&quot;</pre><p>This is read-only. Claude Code searches, reads, and reports. It cannot break anything. According to Anthropic’s benchmarks, Claude scores 72.7% on [SWE-bench Verified](https://www.anthropic.com/research/swe-bench-sonnet) — meaning it resolves real GitHub issues nearly three-quarters of the time. That accuracy matters when you are using it to find bugs.</p><h4><strong>Level 3: Human-in-the-Loop Operator</strong></h4><p>The agent proposes actions and you approve each one.</p><p><strong>**Examples:**</strong> refund approvals, CRM updates, deployment checklists, vendor outreach, code changes.</p><p>When it works: operations, customer support, and engineering workflows. Failure mode: approval fatigue. Fix with batching and better summaries.</p><p><strong>**Claude Code in practice — interactive code changes:**</strong></p><pre>claude &quot;Refactor the authentication middleware to use JWT with<br>refresh tokens. Show me each file change before applying it.<br>Run the test suite after each change.&quot;</pre><p>Claude Code proposes changes, you review diffs, approve each one. It runs tests after every modification. This is the pattern I use daily — the agent does the work, I make the decisions.</p><h4><strong>Level 4: Limited Autonomy</strong></h4><p>The agent executes within strict boundaries.</p><p><strong>**Examples:**</strong> reorder inventory within min/max, auto-label inbox, retry failed jobs, close low-risk tickets, run CI/CD pipelines.</p><p>When it works: repetitive, rules-based tasks with clear guardrails. Failure mode: silent drift. Fix with monitoring, audits, and hard stop conditions.</p><p><strong>**Claude Code in practice — autonomous task execution with boundary config:**</strong></p><pre># CLAUDE.md project config that constrains the agent<br># This file lives in your repo root<br>## Allowed actions<br>- Run tests with `npm test`<br>- Fix lint errors automatically<br>- Update snapshot files<br>- Create git commits for passing changes<br>## Prohibited actions<br>- Do NOT modify database migrations<br>- Do NOT change environment variables<br>- Do NOT push to remote<br>- Do NOT modify files in /config/production/<br>## Stop rules<br>- Stop and ask if any test fails after 2 retry attempts<br>- Stop and ask before modifying more than 5 files in a single change<br>- Stop and ask if a change touches authentication or billing logic</pre><p>The `CLAUDE.md` file is your boundary specification. It tells Claude Code exactly what it can and cannot do before it starts. Combined with [hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) (pre- and post-action scripts), you get an agent that operates autonomously within a strict box.</p><blockquote><strong>If you are starting today, Level 2 plus Level 3 is the sweet spot.**</strong> Read-only analysis combined with human-approved actions gives you 80% of the value with near-zero risk.</blockquote><h3><strong>The Single Most Important Concept: Bounded Agency</strong></h3><p>Do not ask an agent to “handle customer support.” Ask it to “draft replies for returns under $50 and route edge cases.”</p><p>Bounded agency is how you keep agents useful without making them dangerous. A good boundary has four parts:</p><p>1. <strong>**Scope**</strong> — what it is allowed to touch</p><p>2. <strong>**Tools**</strong> — what it can call</p><p>3. <strong>**Limits**</strong> — time, budget, number of steps, rate limits</p><p>4. <strong>**Stop rules**</strong> — when to escalate to a human</p><p>This is boring by design. Boring is safe. Safe is scalable.</p><p><strong>**How Claude Code implements bounded agency:**</strong></p><p>[MCP (Model Context Protocol)](https://modelcontextprotocol.io/) servers define exactly which tools the agent can access. You can give it a database read tool without a write tool. You can give it a Jira comment tool without a ticket-close tool. The permission model <em>*is*</em> the boundary.</p><pre># Agent that can read your database and Slack,<br># but can only write to a markdown file<br>claude - mcp-config ./mcp-readonly.json \<br>&quot;Analyze our top 10 support tickets from last week.<br>Cross-reference with error logs. Write a summary<br>to weekly-support-digest.md&quot;</pre><h3><strong>The Agent Blueprint That Actually Ships</strong></h3><p>Here is a template you can reuse.</p><h4><strong>1. Define the Outcome and Success Criteria</strong></h4><p>Bad: “Improve onboarding.”</p><p>Good: “Reduce time-to-first-value from 20 minutes to under 8 minutes.”</p><p>Write success criteria like a QA spec:</p><p>- Must produce X</p><p>- Must not do Y</p><p>- Must cite sources for Z</p><p>- Must ask for approval when uncertain</p><h4><strong>2. Give It a Small Set of Tools</strong></h4><p>Agents fail when they have too many buttons. Microsoft Research’s work on [Magentic-One](https://www.microsoft.com/en-us/research/blog/magentic-one-a-generalist-multi-agent-system-for-solving-complex-tasks/) found that agent performance degrades when tool count exceeds 10 — the model spends more tokens deciding <em>*which*</em> tool to use than actually using it.</p><p>Common tools that work:</p><p>- Search docs and knowledge base</p><p>- Read-only analytics queries</p><p>- Ticket creation (draft mode)</p><p>- Email draft creation</p><p>- Calendar scheduling</p><p>- Database read for customer context</p><p>Start read-only. Move to write actions only after you have logs and confidence.</p><p><strong>**Claude Code example — minimal tool configuration:**</strong></p><pre>{<br>   &quot;mcpServers&quot;:{<br>      &quot;postgres-readonly&quot;:{<br>         &quot;command&quot;:&quot;npx&quot;,<br>         &quot;args&quot;:[<br>            &quot;-y&quot;,<br>            &quot;@modelcontextprotocol/server-postgres&quot;<br>         ],<br>         &quot;env&quot;:{<br>            &quot;DATABASE_URL&quot;:&quot;postgresql://readonly_user@localhost/myapp&quot;<br>         }<br>      },<br>      &quot;docs-search&quot;:{<br>         &quot;command&quot;:&quot;npx&quot;,<br>         &quot;args&quot;:[<br>            &quot;-y&quot;,<br>            &quot;@anthropic/mcp-docs-server&quot;,<br>            &quot;./docs&quot;<br>         ]<br>      }<br>   }<br>}</pre><p>Two tools. Read-only database. Documentation search. That is enough to build a powerful analysis agent.</p><h4><strong>3. Add Memory Only Where It Matters</strong></h4><p>Memory is not “store everything.” Store only stable, high-value facts:</p><p>- Customer tier, plan limits, preferences</p><p>- Product configuration</p><p>- Common decisions and policies</p><p>If memory is noisy, the agent becomes inconsistent.</p><p>In Claude Code, the `CLAUDE.md` file is your agent’s long-term memory. Project-specific context, coding conventions, architectural decisions — things that do not change between sessions. Keep it focused. I have seen teams dump 2,000 lines into their config and wonder why the agent ignores half of it.</p><h4><strong>4. Force Verification</strong></h4><p>Make the agent prove it is right. This is the step most builders skip, and it is the one that separates demos from production systems.</p><p>Verification patterns:</p><p>- Quote and cite exact policy sections</p><p>- Run a query and include the query text and result</p><p>- Produce a checklist and mark each item as verified or assumed</p><p>- Do a second-pass “critic” step that tries to break the answer</p><p><strong>**Claude Code example — built-in verification:**</strong></p><pre>claude &quot;Fix the failing test in tests/auth.test.js. After fixing it,<br>run the full test suite. If all tests pass, run the linter.<br>Only commit if both pass. Show me the diff before committing.&quot;</pre><p>This is a verification chain: fix, test, lint, diff review, then commit. Each step must succeed before the next one runs. Claude Code does this naturally — it checks tool output and adjusts.</p><h4><strong>5. Use a Clean Handoff Format</strong></h4><p>Humans should not read agent thoughts. They should read decisions.</p><p>A reliable handoff looks like:</p><p>- <strong>**Summary**</strong> (3 bullets max)</p><p>- <strong>**Proposed action**</strong></p><p>- <strong>**Evidence**</strong> (links, citations, logs)</p><p>- <strong>**Risks and edge cases**</strong></p><p>- <strong>**Approval needed**</strong> (yes / no / escalate)</p><h3><strong>Three Agent Use Cases That Work for Almost Any Team</strong></h3><h4><strong>1. Support Triage Agent</strong></h4><p><strong>**Goal:**</strong> reduce response time without sacrificing quality.</p><p>What it does: reads the ticket, classifies intent (refund, shipping, bug, billing), pulls relevant policy and order context, drafts a response, and flags risk (chargeback risk, angry customer, legal language).</p><p><strong>**Boundaries:**</strong> cannot send without approval, cannot offer discounts beyond a threshold, and escalates for safety, legal, threats, or PR risk.</p><h4><strong>2. Growth Research Agent</strong></h4><p><strong>**Goal:**</strong> compress research and competitive analysis.</p><p>What it does: monitors competitor updates, extracts changes in pricing, positioning, and feature announcements, produces a weekly memo with diffs and links, and suggests experiments.</p><p><strong>**Boundaries:**</strong> read-only, must include sources for every claim, and “unknown” is allowed and encouraged.</p><h4><strong>3. Engineering Ops Agent</strong></h4><p><strong>**Goal:**</strong> make the team run with fewer meetings.</p><p><strong>**Claude Code in practice — weekly engineering digest:**</strong></p><pre>claude &quot;Pull the last 7 days of merged PRs from our GitHub repo.<br>Summarize what shipped, what&#39;s still in review, and any PRs<br>with failing checks. Cross-reference with our Jira board to<br>flag tickets that are marked done but don&#39;t have a merged PR.<br>Write the digest to weekly-engineering-update.md&quot;</pre><p><strong>**Boundaries:**</strong> creates drafts only, no production changes, no customer outreach without approval.</p><h3><strong>Why Most Agents Fail in Production</strong></h3><p><strong>**Failure 1: Vague goals.**</strong> “Handle marketing” is not a goal. It is a department. Fix: reduce scope until success is measurable.</p><p><strong>**Failure 2: No ground truth.**</strong> If the agent cannot check its work, it will hallucinate with confidence. Fix: give it access to data and require citations.</p><p><strong>**Failure 3: Tool chaos.**</strong> Too many tools yields unpredictable behavior. Fix: start with 2 to 4 tools, expand slowly.</p><p><strong>**Failure 4: No escalation path.**</strong> Agents need a clear “I am not sure” behavior. Fix: define stop rules and route to a human. In Claude Code, this is the `CLAUDE.md` stop rules section — explicit instructions on when to ask instead of act.</p><p><strong>**Failure 5: No monitoring.**</strong> If you cannot see what it did, you cannot trust it. Fix: log prompts, tool calls, outputs, and approvals. Sample and audit weekly.</p><blockquote><strong>**Pro tip:**</strong> Claude Code logs every tool call and its output by default. Use `claude — verbose` to see the full chain of reasoning, tool calls, and decisions. This is your audit trail.</blockquote><h3><strong>The Minimum Viable Agent Stack</strong></h3><p>If you are building an agent system today, keep it straightforward:</p><p>- <strong>**Agent runtime:**</strong> an orchestrator that runs the loop (Claude Code, LangGraph, or a custom loop)</p><p>- <strong>**Tools:**</strong> your APIs wrapped with strict schemas and permissions</p><p>- <strong>**Memory:**</strong> a small context store plus a retrieval index for docs</p><p>- <strong>**Observability:**</strong> logs for every run, plus a dashboard for failures</p><p>- <strong>**Human approval UI:**</strong> where the agent proposes actions and you approve</p><p>If you cannot see the tool calls and the evidence, you do not have an agent. You have a demo.</p><p>For builders who want to skip the infrastructure, Claude Code with MCP servers is the fastest path to a real agent. You define tools as MCP servers, configure boundaries in `CLAUDE.md`, and the agent loop, memory, and tool calling are handled for you. I have used this pattern to build internal tools that went from idea to production in a single afternoon.</p><h3><strong>Resources to Go Deeper</strong></h3><p>If you want to move from reading about agents to actually building them, these are worth your time:</p><p><a href="https://anthropic.skilljar.com/introduction-to-agent-skills"><strong>Introduction to Agent Skills</strong></a><strong>: </strong>Anthropic’s official course on building Skills for Claude Code. Covers writing `SKILL.md` files, structuring skill directories, restricting tool access, distributing skills across teams, and wiring skills into custom subagents. If you are serious about making Claude Code do repeatable, specialized work, start here.</p><p><a href="https://github.com/VoltAgent/awesome-claude-code-subagents"><strong>Awesome Claude Code Subagents</strong></a><strong>: </strong>A curated collection of 127+ specialized Claude Code subagents organized by domain: core development, infrastructure, security, data/AI, and meta-orchestration. The real value is in the multi-agent patterns — how to coordinate specialized agents for complex workflows instead of asking one agent to do everything.</p><p><a href="https://github.com/hesreallyhim/awesome-claude-code"><strong>Awesome Claude Code</strong></a><strong>: </strong>The most comprehensive directory of Claude Code tools, skills, workflows, hooks, and `CLAUDE.md` templates. Over 32,000 stars. If you need a starting point for anything — IDE integrations, usage monitoring, slash commands, status lines — it is probably cataloged here.</p><p><a href="https://github.com/nextlevelbuilder/ui-ux-pro-max-skill"><strong>UI/UX Pro Max Skill</strong></a><strong>: </strong>A Claude Code skill that generates complete design systems from project requirements. 67 UI styles, 161 color palettes, 57 typography pairings, and a reasoning engine that tailors recommendations to your industry. A good example of what a well-built skill looks like in practice — it auto-activates when you request design work and produces actionable output, not generic advice.</p><h3><strong>The Pragmatic Take</strong></h3><p>AI agents are not a replacement for teams. They are a force multiplier for workflows.</p><p>If you build them with bounded scope, verification, and clean handoffs, they pay back fast. If you build them as “do everything” bots, they become a liability.</p><p>Start small. Pick one workflow you repeat weekly. Give the agent a tight box. Make it prove its work. Then expand.</p><p>The builders who win with agents in 2026 will not be the ones with the most sophisticated architectures. They will be the ones who defined the clearest boundaries.</p><p><em>*If you are building something with agents and want to compare notes — what workflow are you automating first? Drop a comment or connect with me on </em><a href="https://www.linkedin.com/in/kuldeepchowhan"><em>LinkedIn</em></a><em>.*</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=781364a19f5b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/ai-agents-for-normal-builders-a-practical-guide-to-getting-real-work-done-781364a19f5b">AI Agents for Normal Builders: A Practical Guide to Getting Real Work Done</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Prompting. Start Designing the Loop.]]></title>
            <link>https://medium.com/kuldeep/stop-prompting-start-designing-the-loop-00646109b4fe?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/00646109b4fe</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[loop-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Mon, 15 Jun 2026 09:58:32 GMT</pubDate>
            <atom:updated>2026-06-15T09:58:33.942Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><figure><img alt="A clean, modern conceptual illustration for a tech article about AI “loop engineering.”" src="https://cdn-images-1.medium.com/max/1024/1*V45jMMKUwmQ7Q2L6vaJLGg.png" /></figure><h3>The shift from hand-prompting your coding agent to engineering the system that prompts it for you</h3><p><em>Inspired by a thread from </em><a href="https://x.com/0xCodez/status/2064374643729773029"><em>@0xCodez</em></a><em> on “loop engineering,” which itself pulls from Anthropic’s engineering docs and Addy Osmani’s writing. This is my own take on the idea — what I think holds up, and the parts most people gloss over.</em></p><p>Most of us still drive our coding agents by hand. You write a prompt. You wait. You read the diff. You write the next prompt. The agent is a power tool and your hand never leaves the trigger.</p><p>That arrangement is quietly ending. Not because the chat box stops working, but because the leverage moved. For two years the gains came from better prompting — more context, sharper instructions, a cleaner one-shot. The agents are now good enough that the next floor up is more valuable: the <em>system</em> that decides what the agent works on, when it runs, what gate has to pass before anything ships, and what knowledge survives between runs.</p><p>That’s loop engineering. You design a small system once, and the system prompts the agent from then on. You stop being the prompter and become the person who builds the thing that prompts.</p><p>Here’s the honest version, in three tiers: figure out whether you actually need a loop, learn the five pieces every loop is made of, then build the smallest one that helps you instead of bankrupting you.</p><h3>Part 1 — The why, and the test you run before building anything</h3><h3>1. Loop engineering is replacing yourself as the prompter</h3><p>The job to date has been: write prompt, share context, read result, write next prompt. You held the tool the whole time.</p><p>A loop changes the shape. It finds the work, hands it to the agent, checks the result, records what happened, and decides the next move — without you in the chair. Addy Osmani breaks the machinery into six parts (automations, worktrees, skills, connectors, sub-agents, and the state that ties them together), and we’ll walk all of them.</p><p>The number everyone quotes is that Anthropic engineers merge roughly eight times as much code per day as in 2024. Anthropic themselves call that “almost certainly an overstatement.” Fine — the multiplier is debatable. The mechanism is not: the leverage point moved from <em>typing prompts</em> to <em>designing the loop that prompts</em>.</p><h3>2. Run the four-condition test before you build</h3><p>A loop only pays for itself when all four of these are true. Miss one and the loop costs more than it returns.</p><p><strong>The task repeats.</strong> A loop amortizes its setup over many runs. For a one-off, a good prompt is faster and cheaper. If the work doesn’t recur at least weekly, you don’t have a loop — you have a script you ran once.</p><p><strong>Verification is automated.</strong> The loop needs something that can fail the work without you present: a test suite, a type checker, a linter, a build. No automated check means you’re back to reading every diff — the exact job the loop was supposed to delete.</p><p><strong>Your token budget can absorb the waste.</strong> Loops re-read context, retry, and explore. That burns tokens whether or not the run ships anything. This is why loops feel obvious to people with effectively free tokens and reckless to people on a metered plan.</p><p><strong>The agent has a senior engineer’s tools.</strong> Logs, a reproduction environment, the ability to run its own code and see what breaks. Without that, the loop iterates blind.</p><h3>3. Loops favor whoever can spend</h3><p>The economics aren’t universal, and pretending they are is how people get burned. The folks calling loop engineering obvious usually have unmetered tokens. The folks calling it reckless are usually on a $20 consumer plan trying to run heavy verification loops without triggering a surprise invoice.</p><p><strong>Who actually wins:</strong> teams with repetitive, machine-checkable work and the budget to run it — test triage, dependency bumps, lint-and-fix passes, issue-to-PR drafts on a codebase with real test coverage. Codebases with strong suites already in place. Async-first teams that already lean on multi-agent patterns and just need the orchestration layer.</p><p><strong>Who should skip it for now:</strong> solo builders on consumer plans (the bill arrives before the productivity does), anyone working on code with no automated verification (a loop with no real check is just the agent agreeing with itself on repeat), and teams whose real bottleneck is <em>review capacity</em> rather than typing speed. If review was already the constraint, a loop just makes the queue longer.</p><p>For one-offs, exploratory work, or anything where “done” is a judgment call, a single well-aimed prompt still wins. Loop engineering is real — most developers just don’t need it yet.</p><h3>4. The 30-second loop check</h3><p>The four-condition test is the strategic call. This is the tactical one you run on a specific task. Miss a box, keep it as a manual prompt.</p><ol><li>The task happens at least weekly.</li><li>A test, type check, build, or linter can reject bad output.</li><li>The agent can actually run the code it changes.</li><li>The loop has a hard stop — token budget, iteration count, or time limit.</li><li>A human reviews before anything irreversible: merge, deploy, dependency changes.</li></ol><p><strong>Good first loops:</strong> CI failure triage (scan nightly, classify, draft fixes for the easy ones), dependency bump PRs, lint-and-fix passes on PR open, flaky-test reproduction, issue-to-PR drafts on code with strong tests.</p><p><strong>Bad first loops:</strong> architecture rewrites, auth or payments code, production deploys, vague product work — anything where “done” is a judgment call. Those need a human in the chair.</p><h3>Part 2 — The five building blocks</h3><h3>5. Automations: the heartbeat</h3><p>Automations are what make a loop a loop instead of one run you happened to do once. They fire on a schedule, an event, or a trigger. Everything else hangs off them.</p><p>In Codex, that’s the Automations tab — pick a project, set a prompt and a cadence, choose a local checkout or a background worktree. Runs that find something land in a triage inbox; runs that find nothing archive themselves. In Claude Code, three primitives compose into the same shape: a session-scoped cadence, scheduled tasks that survive restarts, and cloud routines that run with your laptop closed — paired with hooks for lifecycle events.</p><p>The distinction worth internalizing is <em>cadence</em> versus <em>goal</em>. A cadence re-runs on a timer regardless of state. A goal keeps going until a condition you wrote is actually true — and crucially, a <em>separate</em> small model checks completion, so the agent that wrote the code isn’t the one grading it. That’s the maker-versus-checker split applied to the stop condition itself, and it’s the single cheapest defense against a loop that quits early or never quits at all.</p><h3>6. Worktrees: parallelism without the pileup</h3><p>The moment you run more than one agent, files start colliding — same headache as two engineers committing to the same lines without talking. A git worktree fixes it mechanically: a separate working directory on its own branch, sharing the repo history, so one agent’s edits literally can’t touch another’s checkout.</p><p>Both major tools support this — Codex builds it in, Claude Code exposes worktrees directly plus an isolation setting on sub-agents so each helper gets a fresh, self-cleaning checkout. But the tool isn’t your ceiling. <em>You</em> are. Your review bandwidth decides how many parallel agents you can actually run, not the number of worktrees you can spin up.</p><h3>7. Skills: write the project knowledge once, read it every run</h3><p>A Skill is how you stop re-explaining your project every session like you’re talking to a goldfish. It’s a folder with a SKILL.md inside holding instructions and metadata, plus optional scripts and references. Both tools use the same format.</p><p>This matters disproportionately for loops. A loop <em>without</em> skills re-derives your entire project context from zero every cycle. With skills, intent compounds — the conventions, the build steps, the “we don’t do it this way because of that one incident” all live outside the conversation and get read on every run. A good CI-triage skill, for instance, encodes classification rules (env vs. flake vs. real bug vs. dependency vs. infra), fix patterns (“auth tests → check the middleware first”), and a hard “never do” list (don’t disable failing tests, don’t touch billing, don’t change CI config without a human).</p><h3>8. Connectors: let the loop touch your real tools</h3><p>A loop that can only see the filesystem is a tiny loop. Connectors — built on the Model Context Protocol — let the agent read your issue tracker, query a database, hit a staging API, or drop a message in Slack. Codex and Claude Code both speak MCP, so a connector you write for one usually just works in the other.</p><p>This is the difference between an agent that says “here’s the fix” and a loop that opens the PR, links the ticket, and pings the channel once CI goes green. The connectors that pay back fastest, roughly in order: <strong>GitHub</strong> (read repos, open PRs, react to webhooks — the biggest day-one win), <strong>Linear or Jira</strong> (update and close tickets as the loop progresses), <strong>Slack</strong> (post results, escalate, summarize overnight runs), and <strong>your error tracker</strong> (let the loop investigate live alerts and draft fixes for the frequent ones).</p><h3>9. Sub-agents: keep the maker away from the checker</h3><p>The most useful structural move in a loop is splitting the agent that <em>writes</em> from the agent that <em>checks</em>. Osmani’s line nails it: the model that wrote the code is “way too nice grading its own homework.” A second agent — different instructions, sometimes a different model — catches the things the first one talked itself into.</p><p>If that sounds familiar, it should. It’s the evaluator-optimizer pattern from Anthropic’s December 2024 engineering post, wearing a new name. One model generates, another critiques, repeat. The vocabulary went viral in 2026; the idea was documented eighteen months earlier.</p><p>In practice you define agents as config files — Codex spawns sub-agents on request and folds their results back into one answer; Claude Code does the same and supports teams that pass work between them. The usual split is one agent explores, one implements, one verifies against the spec. Your security reviewer can be a strong model on high effort while your explorer is something fast and read-only. Sub-agents cost more tokens because each runs its own model and tool work — so spend them where a second opinion is actually worth paying for. Inside a loop that runs while you’re asleep, a verifier you trust is the only reason you can walk away.</p><h3>Part 3 — Build it right or don’t build it</h3><h3>10. The state file: the agent forgets, the file doesn’t</h3><p>This is the piece that sounds too dumb to matter and is actually the spine of every working loop. It’s a file — markdown, a Linear board, a JSON blob — that lives <em>outside</em> the single conversation and holds what’s done and what’s next.</p><p>Agents have short memory by default. What they learn today is gone tomorrow unless you write it down. Osmani’s rule: the agent forgets, the repo does not. A loop without persistent state restarts every run; a loop with state resumes.</p><p>A useful state file tracks the last run, what’s in progress, what completed, what got escalated to humans, and — most valuable of all — a running “lessons learned” log (“this Windows runner needs bash, not PowerShell”; “the checkout E2E tests need a Stripe webhook secret, skip if missing”). Keep it as a versioned STATE.md in the repo for solo and small-team work, or in an external system like Linear or GitHub Issues when multiple humans need visibility. For long-running loops that drift, pair the state file with a standing VISION.md or AGENTS.md the agent rereads each run. State tells the agent where it <em>is</em>; the spec tells it where to <em>go</em>.</p><h3>11. The minimum viable loop</h3><p>If you passed the four-condition test, build the smallest thing that works before anything fancy. Four parts, no swarm:</p><ul><li><strong>One automation</strong> — a scheduled run on a cadence that stops on a clear condition.</li><li><strong>One skill</strong> — a single SKILL.md storing the context the agent would otherwise rederive every run.</li><li><strong>One state file</strong> — so tomorrow resumes instead of restarting.</li><li><strong>One gate</strong> — the test, type check, or build that fails bad work automatically. This is the part that decides whether the loop helps or just spends.</li></ul><p>Order matters: get one <em>manual</em> run reliable first. Turn it into a skill. Wrap it in a loop. <em>Then</em> schedule it. Skipping ahead is how loops fail in production.</p><p>And measure the right thing. The metric is <strong>cost per accepted change</strong> — not tokens spent, not tasks attempted, not loops scheduled. If your accepted-change rate is below 50%, you’re doing the review work the loop was supposed to save you from, and the loop is losing.</p><h3>12. The Ralph Wiggum loop: failing quietly while spending loudly</h3><p>Geoffrey Huntley named this failure mode. An agent meant to emit a completion signal only when finished emits it early, the loop exits on a half-done job, and — without a hard gate — it keeps spending while looking like it’s working. It shows up when there’s no real verifier (just a second agent asked to “review,” i.e. two optimists agreeing), soft completion conditions defined by the agent’s judgment rather than a test, and no hard stop, so the loop runs until something external kills it.</p><p>The fix is the gate from step 11: something <em>objective</em> that can fail the work. A test that passes or fails. A build that compiles or doesn’t. A linter that returns zero or non-zero. Not a verifier with an opinion. Three other measured failure modes are worth knowing: <strong>goal drift</strong> over long sessions (each summarization is lossy; “don’t do X” quietly evaporates by turn 47 — mitigate with a reread spec), <strong>self-preferential bias</strong> (the maker grades itself too kindly — mitigate with a separate verifier), and <strong>agentic laziness</strong> (the loop declares “done enough” at partial completion — mitigate with an objective stop condition checked by a fresh model).</p><h3>13. Comprehension debt and cognitive surrender</h3><p>This is the failure that gets <em>worse</em> as the loop gets <em>better</em>, and it’s the one I’d watch hardest.</p><p><strong>Comprehension debt:</strong> the faster the loop ships code you didn’t write, the wider the gap between what the repo contains and what you understand. The bill that actually hurts isn’t tokens. It’s the day you have to debug a system nobody on the team has read.</p><p><strong>Cognitive surrender:</strong> the pull to stop forming an opinion and just accept whatever the loop returns. Designing the loop is the cure when you do it with judgment, and the accelerant when you do it to avoid thinking. Same action, opposite outcome.</p><p>The mitigations aren’t technical. Read the diffs — skip that and you’re renting comprehension debt at compound interest. Spot-check the gate: pick a few PRs the loop opened and confirm the test that approved them actually catches the failure you care about, because gates rot. Keep the loop on small, machine-checkable changes and off architecture. And pair-design your loops with a teammate; a second set of eyes at design time catches blind spots the loop will otherwise exploit forever.</p><h3>14. The security tax: an unattended loop is an unattended attack surface</h3><p>A loop running unattended is also an attack surface running unattended. The threats are concrete. <strong>Generated code shipping unreviewed</strong> — the loop opens PRs faster than a human reads them, so without a gate that includes security checks (SAST, dependency audit, secret scanning), insecure code merges itself. <strong>Skills as injection vectors</strong> — a loop that auto-installs skills inherits every prompt injection hiding in their descriptions, so audit sources first. <strong>Credentials in logs</strong> — verbose debug logging during a long run scatters secrets across logs you don’t monitor; disable it in production and sanitize what remains. <strong>Permission scope creep</strong> — a loop tested read-only gets “just one” write permission added for convenience and never re-audited. Re-audit every 30 days.</p><h3>The mistakes that turn loops into money pits</h3><p>Building without running the four-condition test. No objective gate (a second agent asked to “review” is just a second optimist). One agent doing both writing and verifying. No state file, so every run restarts from zero. Vague stop conditions — “done when it looks good” never holds. No token cap, so an ambitious loop quietly burns 5–10× what you expected. Running heavy verification loops on a consumer plan. Auto-installing community skills without reading the source. Pointing loops at judgment-call work like architecture, auth, and payments. And the expensive one: not reading the diffs.</p><h3>The leverage moved. Your job moved with it.</h3><p>For two years the leverage in working with coding agents sat at the prompt — better prompts, better context, better one-shot output. That phase is closing. The agents got good enough that the next leverage point is one floor up: the system that decides what they work on, when, with what gate, and what state survives between runs.</p><p>But the honest version of this story isn’t “everyone should rush to build loops.” Most developers don’t need one yet — not until the task repeats, verification is automated, the budget can absorb the waste, and the agent has a senior engineer’s tools. Miss one condition and the loop costs more than it returns.</p><p>If you pass the test, build small. One automation, one skill, one state file, one gate. Get a manual run reliable, turn it into a skill, wrap it in a loop, then schedule it. Order matters — skip ahead and you’re paying for a system nobody understands.</p><p>The work didn’t get easier. The leverage point moved. Build the loop, and stay the engineer.</p><p><em>Original thread credit: </em><a href="https://x.com/0xCodez/status/2064374643729773029"><em>@0xCodez</em></a><em>. This piece is my own framing of the idea.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=00646109b4fe" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/stop-prompting-start-designing-the-loop-00646109b4fe">Stop Prompting. Start Designing the Loop.</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Agents Are Not Magic. They Are Loops.]]></title>
            <link>https://medium.com/kuldeep/ai-agents-are-not-magic-they-are-loops-b2e8f9f2d4be?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/b2e8f9f2d4be</guid>
            <category><![CDATA[agents]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Wed, 18 Feb 2026 04:40:35 GMT</pubDate>
            <atom:updated>2026-02-18T04:40:37.300Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xhDAUXrzPjca31A-yprCUQ.png" /></figure><h3>AI Agents Are Not Magic. They Are Loops.</h3><p>Most people talk about AI agents like they are tiny interns living inside your laptop.</p><p>That framing is cute, and also misleading.</p><p>An agent is not a personality. It is not “ChatGPT, but with vibes.” It is a system that repeatedly does three things:</p><ol><li>Understand a goal</li><li>Decide an action</li><li>Execute that action using tools<br>…then learn from the result and repeat</li></ol><p>If you remember only one thing, remember this:</p><p><strong>Agents are loops with tools and guardrails.</strong></p><h3>The simplest definition that holds up</h3><p>A chatbot answers.<br>An automation triggers.<br>An agent decides and acts.</p><p>A working definition:</p><p><strong>An AI agent is a software loop that can plan and take actions (via tools) toward a goal, using feedback to adjust.</strong></p><p>That means it needs five ingredients:</p><ul><li><strong>Goal</strong>: what “done” means</li><li><strong>Context</strong>: the relevant facts (docs, tickets, CRM, prior decisions)</li><li><strong>Tools</strong>: APIs it can use (search, email, calendar, database, browser actions)</li><li><strong>Constraints</strong>: what it is not allowed to do</li><li><strong>Feedback</strong>: signals that tell it whether it is getting warmer or colder</li></ul><p>If any one of these is missing, your “agent” becomes either a chatbot with extra steps or a chaos machine with API keys.</p><h3>The agent loop (the part everyone forgets)</h3><p>Here is the loop in plain language:</p><ol><li><strong>Observe</strong>: read the request and context</li><li><strong>Plan</strong>: pick a short sequence of steps</li><li><strong>Act</strong>: call a tool (search, write, update, fetch, schedule)</li><li><strong>Check</strong>: validate output against rules and reality</li><li><strong>Repeat or stop</strong>: either continue or hand off to a human</li></ol><p>Most failures happen at step 4.</p><p>People build an agent that can do things, then skip the boring part where it proves it did the right thing.</p><h3>The autonomy ladder (how to stop being reckless)</h3><p>Not every workflow needs a fully autonomous agent. The safest path is to choose a level and earn your way up.</p><p><strong>Level 0: Suggests only</strong><br>Gives options. No changes.</p><p><strong>Level 1: Drafts</strong><br>Writes emails, tickets, briefs. Human sends.</p><p><strong>Level 2: Executes with approval</strong><br>Agent proposes actions, human clicks “approve.”</p><p><strong>Level 3: Executes within limits</strong><br>Agent can act without approval, but only in a bounded sandbox (low-risk tools, tight permissions, budgets).</p><p><strong>Level 4: Executes high-risk actions</strong><br>Money movement, legal commitments, production changes. This is where you need serious controls, audits, and monitoring.</p><p>Most teams should live at <strong>Level 1 to Level 3</strong> for a long time. The ROI is already huge there.</p><h3>Three agents that help almost everyone (not niche)</h3><h3>1) The Research Brief Agent</h3><p>Input: “I need to understand X.”<br>Output: a structured brief with sources, assumptions, counterarguments, and a recommendation.</p><p>Why it works: research is naturally iterative, and the “check” step can be “cite sources and list uncertainties.”</p><p>Guardrail: require citations, and require an “assumptions” section.</p><h3>2) The Universal Inbox Agent</h3><p>Input: email, support tickets, Slack pings, contact forms<br>Output: triage, routing, summaries, and suggested replies</p><p>Why it works: 80 percent of inbox work is classification and drafting.</p><p>Guardrail: it can draft and categorize, but humans approve sends and refunds.</p><h3>3) The Ops Follow-Up Agent</h3><p>Input: meeting notes + decisions + owners<br>Output: action items, reminders, status checks, weekly rollups</p><p>Why it works: most projects fail from missed follow-ups, not lack of intelligence.</p><p>Guardrail: it can nag, not commit.</p><h3>The boring checklist that makes agents actually work</h3><p>If you want an agent to be dependable, build it like you would build a payment system: assume failure by default.</p><p><strong>1) Tool permissions</strong><br>Start read-only. Add write actions later. Separate credentials by risk.</p><p><strong>2) Explicit boundaries</strong><br>Write what it must never do. Example: “Do not send external emails without approval.”</p><p><strong>3) Structured outputs</strong><br>Use schemas (even simple ones) so output can be validated before actions run.</p><p><strong>4) Deterministic checks</strong><br>Have non-AI checks for important constraints: format validators, allowlists, thresholds.</p><p><strong>5) Audit trail</strong><br>Log the plan, tool calls, and final outputs. Debugging agents without logs is like debugging a production outage blindfolded.</p><p><strong>6) Evaluation set</strong><br>Save 20 to 50 real examples. Run the agent against them every time you change prompts or tools. If you do not measure, you are just vibing.</p><h3>The most common failure modes (so you can avoid them)</h3><p><strong>Failure mode 1: The goal is fuzzy</strong><br>“Help with sales” is not a goal. “Draft 3 follow-up emails based on these notes” is.</p><p><strong>Failure mode 2: Too many tools too early</strong><br>Every tool is a new way to fail. Start with one or two.</p><p><strong>Failure mode 3: No feedback loop</strong><br>If the agent cannot check its work (or you cannot check it), it will confidently wander.</p><p><strong>Failure mode 4: People skip rollout discipline</strong><br>Run in shadow mode first. Compare outputs to what humans did. Then add approvals. Then remove approvals for low-risk actions only.</p><h3>A one-page Agent Spec template (copy/paste)</h3><p><strong>Agent name:</strong><br><strong>Goal:</strong><br><strong>Inputs:</strong><br><strong>Outputs (format):</strong><br><strong>Tools allowed:</strong><br><strong>Tools disallowed:</strong><br><strong>Constraints:</strong><br><strong>Approval gates:</strong><br><strong>Success metrics:</strong><br><strong>Failure handling:</strong><br><strong>Logging and audit:</strong><br><strong>Evaluation set link:</strong></p><p>If you cannot fill this out in 10 minutes, the agent is not ready.</p><h3>The real point</h3><p>Agents are not a leap of faith. They are an engineering and product discipline.</p><p>When you treat them as loops with guardrails, you get something better than a demo: a teammate that scales work without scaling headcount.</p><p>Build small. Prove reliability. Increase autonomy only when the system earns it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b2e8f9f2d4be" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/ai-agents-are-not-magic-they-are-loops-b2e8f9f2d4be">AI Agents Are Not Magic. They Are Loops.</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Stop Sending Marketing From Your Root Domain]]></title>
            <link>https://medium.com/kuldeep/stop-sending-marketing-from-your-root-domain-847051a7139f?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/847051a7139f</guid>
            <category><![CDATA[klaviyo]]></category>
            <category><![CDATA[founders]]></category>
            <category><![CDATA[marketing]]></category>
            <category><![CDATA[startup]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 06:02:24 GMT</pubDate>
            <atom:updated>2026-02-05T06:01:11.713Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OsYQHh-x87uA5drzRqgE9Q.png" /></figure><p>Email deliverability is not “marketing.” It is revenue uptime.</p><p>If your emails do not land in the inbox, you lose money quietly. No alerts. No dashboards. Just fewer opens, fewer clicks, fewer orders, and a bunch of “Klaviyo is not working” vibes.</p><p>Most founder deliverability problems are not copy problems. They are domain architecture problems.</p><p>This is the playbook I wish more founders followed before sending their first campaign.</p><p>(Quick note: this is not legal advice or security advice. It is an operator’s guide.)</p><h3>The mistake: sending everything from your root domain</h3><p>Many brands start by sending marketing from hello@yourbrand.com because it looks clean and consistent.</p><p>Two issues show up fast:</p><ol><li><strong>You risk your root domain reputation.</strong> If marketing deliverability dips, it can spill into your important email streams.</li><li><strong>DMARC fails are common when a third party is involved.</strong> If SPF or DKIM do not align with the domain in your visible “From” address, inboxes get suspicious.</li></ol><p>The fix is simple and boring:</p><h3>The pattern: split email by purpose using subdomains</h3><p>Use separate subdomains for separate email streams:</p><ul><li><strong>Marketing:</strong> notify.yourbrand.com</li><li><strong>Transactional:</strong> orders.yourbrand.com (or mail.yourbrand.com)</li><li><strong>Humans:</strong> keep your normal mailbox on yourbrand.com (Google Workspace, Outlook, etc.)</li></ul><p>This gives you reputation isolation. Marketing can take risks without poisoning transactional deliverability.</p><h3>The three things that decide DMARC pass or fail</h3><p>DMARC is the bouncer at the door. It asks:</p><p>“Does the visible From domain match a domain that authenticated via SPF or DKIM?”</p><p>There are three moving parts:</p><ul><li><strong>SPF</strong>: says which servers are allowed to send on behalf of a domain</li><li><strong>DKIM</strong>: cryptographic signature proving the sender is authorized</li><li><strong>DMARC</strong>: tells inboxes what to do when SPF and DKIM do not line up with your From domain</li></ul><p>DMARC passes when at least one of these is true:</p><ul><li>SPF passes and aligns with your From domain</li><li>DKIM passes and aligns with your From domain</li></ul><p>If neither aligns, DMARC fails. That is the whole game.</p><h3>Why DMARC fails in Klaviyo setups</h3><p>A common failure mode looks like this:</p><ul><li>You set “From” as hello@yourbrand.com</li><li>Klaviyo sends the email through its infrastructure</li><li>The authenticated domains (SPF and DKIM) do not align with yourbrand.com</li></ul><p>Result: DMARC fail, or “soft fail” behavior like spam placement and warning banners.</p><h3>Step-by-step: the clean Klaviyo setup</h3><h3>Step 1: Pick the From domain you want for marketing</h3><p>Decide the visible From address for marketing:</p><ul><li>Good default: hello@notify.yourbrand.com</li><li>Keep the “From name” consistent (customers notice the name more than the subdomain)</li></ul><h3>Step 2: Set up a branded sending domain in Klaviyo</h3><p>In Klaviyo, configure a branded sending domain so DKIM and related auth can align properly.</p><p>This step is mostly DNS work. The point is to make your emails authenticate as your domain, not as a generic shared domain.</p><h3>Step 3: Add a DMARC record that starts in monitor mode</h3><p>Start with DMARC in monitoring mode so you can see what is failing before you enforce.</p><p>You are looking for patterns:</p><ul><li>which sources are sending</li><li>which ones are failing alignment</li><li>whether your transactional stream is already clean</li></ul><pre>Host/Name: _dmarc<br>Type: TXT<br>Value: v=DMARC1; p=none; rua=dmarc@yourbrand.com; ruf=dmarc@yourbrand.com; fo=1; adkim=r; aspf=r; pct=100</pre><h3>Step 4: Set up dedicated click tracking (optional, but worth it)</h3><p>Link tracking domains can affect trust and deliverability. Use dedicated click tracking when you can so links look like they come from your brand, not a generic redirect.</p><h3>Step 5: Verify with real headers, not just dashboards</h3><p>Send a test email to Gmail and view “Show original.”</p><p>Confirm:</p><ul><li>SPF: pass</li><li>DKIM: pass</li><li>DMARC: pass</li><li>The “From” domain is exactly what you think it is</li></ul><h3>Debug checklist: when someone says “DMARC failed”</h3><p>When you see “DMARC failed,” do not guess. Check:</p><ol><li>What is the exact domain in the visible “From” header?</li><li>Did DKIM pass, and what is the DKIM signing domain (d=)?</li><li>Did SPF pass, and what is the envelope domain (Return-Path / Mail-From)?</li><li>Does either SPF or DKIM align with the From domain?</li></ol><p>If the answer is “neither aligns,” the fix is not copy. It is domain alignment.</p><h3>Rollout plan that avoids self-inflicted outages</h3><ol><li>Set DMARC to monitoring (p=none)</li><li>Fix misaligned senders (Klaviyo, Shopify, support tools, anything else)</li><li>Move to quarantine once you are confident</li><li>Move to reject only when your report data is clean</li></ol><p>Boring is good. Boring delivers.</p><h3>What I would do if I were starting today</h3><ul><li>Use notify.yourbrand.com for marketing from day one</li><li>Use a separate subdomain for transactional</li><li>Keep humans on the root domain</li><li>Start DMARC in monitor mode and graduate to enforcement over time</li><li>Treat deliverability like production reliability, because it is</li></ul><h3><strong>References</strong></h3><p>Klaviyo: Understanding email authentication</p><p><a href="https://help.klaviyo.com/hc/en-us/articles/4402601857307">https://help.klaviyo.com/hc/en-us/articles/4402601857307</a></p><p>Klaviyo: How to set up a branded sending domain</p><p><a href="https://help.klaviyo.com/hc/en-us/articles/115000357752">https://help.klaviyo.com/hc/en-us/articles/115000357752</a></p><p>Klaviyo: How to set up dedicated click tracking</p><p><a href="https://help.klaviyo.com/hc/en-us/articles/360001550572">https://help.klaviyo.com/hc/en-us/articles/360001550572</a></p><p>Shopify: Setting up your email (DMARC + DKIM/SPF guidance)</p><p><a href="https://help.shopify.com/en/manual/intro-to-shopify/initial-setup/setup-your-email">https://help.shopify.com/en/manual/intro-to-shopify/initial-setup/setup-your-email</a></p><p>DMARC alignment basics (strict vs relaxed)</p><p><a href="https://www.valimail.com/blog/what-is-dmarc-alignment/">https://www.valimail.com/blog/what-is-dmarc-alignment/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=847051a7139f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/stop-sending-marketing-from-your-root-domain-847051a7139f">Stop Sending Marketing From Your Root Domain</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Naming Your Platform vs Your Control Plane (and keeping codenames from escaping)]]></title>
            <link>https://medium.com/kuldeep/naming-your-platform-vs-your-control-plane-and-keeping-codenames-from-escaping-e2b4b18b8a44?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/e2b4b18b8a44</guid>
            <category><![CDATA[founders]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Thu, 29 Jan 2026 04:31:36 GMT</pubDate>
            <atom:updated>2026-01-29T04:31:34.873Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GPgS-Am3lelLnjdm8nsQiw.png" /></figure><p>Most naming problems are not creativity problems. They are architecture problems.</p><p>If you do not deliberately name the layers of your product, your users will do it for you. They will invent shortcuts, mix terms, and turn your Slack codenames into your customer-facing vocabulary. That is how you end up with pricing pages that say one thing, docs that say another, and support tickets that use a third name you swore was “internal only.”</p><p>This is the decision framework I wish more founders wrote down.</p><h3>The three names you are actually choosing</h3><p>Early-stage SaaS and infra companies usually think they are choosing one name. You are choosing three:</p><ol><li><strong>The platform name</strong><br>The thing you sell and market.</li><li><strong>The control plane name</strong><br>The place users go to configure, manage, and observe the system.</li><li><strong>The internal codename</strong><br>The temporary label your team uses to move fast without bike shedding.</li></ol><p>Confusing these is expensive. Fixing it later is more expensive.</p><h3>Vocabulary check: what “control plane” really means</h3><p>In systems land, “control plane” is not a brand. It is a role.</p><p>Kubernetes is the cleanest mental model: a cluster has a <strong>control plane</strong> and one or more worker nodes, and the control plane includes the components that manage the cluster (API server, scheduler, controllers, etc.). [1]</p><p>That concept shows up everywhere in modern products, even when the product does not use the term publicly.</p><p>The best companies often do not over-brand this layer. They call it what it is:</p><ul><li>AWS uses the <strong>AWS Management Console</strong>, described as a web-based application providing centralized access to service consoles. [2]</li><li>Google Cloud uses <strong>Cloud Console</strong> as the web interface to manage cloud resources and services. [3]</li></ul><p>This is your first hint: your admin UI is usually a functional name problem, not a poetic name problem.</p><h3>Step 1: pick your brand architecture (do this before wordsmithing)</h3><p>Brand architecture is the structure that defines how a master brand relates to sub-brands, products, and experiences. [5]</p><p>Most teams skip this step and jump straight into “cool names.” That is how you accidentally create a second brand you now have to maintain forever.</p><p>For most early-stage companies, the right default is:</p><h3>The “Branded House” default: master brand + descriptor</h3><p>A branded house approach keeps one master brand and uses clear descriptors for the rest. It compounds equity and reduces confusion. [6]</p><p>A practical pattern looks like this:</p><ul><li>Platform: <strong>Findry</strong></li><li>Admin UI: <strong>Findry Control Plane</strong></li><li>Other surfaces: <strong>Findry CLI</strong>, <strong>Findry SDK</strong>, <strong>Findry Agent Runtime</strong></li></ul><p>This keeps the mental model simple and makes procurement and security reviews easier because everything looks like one coherent system.</p><h3>When you should not do this</h3><p>If the control plane is sold to a different buyer, in a different deal cycle, with a meaningfully different value proposition, then you may want a sub-brand or an endorsed brand. Most startups do not have that situation at the start. Many think they do, and later realize they do not.</p><p>If you want a structured vocabulary for this, Aaker and Joachimsthaler’s <strong>Brand Relationship Spectrum</strong> is a good tool for deciding how tightly a new offering should tie to the master brand. [7]</p><h3>Step 2: decide whether the control plane deserves a “name” at all</h3><p>Your control plane can be:</p><ul><li><strong>A purely functional label</strong>: Console, Dashboard, Admin</li><li><strong>A branded descriptor</strong>: Control Plane, Studio, Hub</li><li><strong>A separate product brand</strong>: rare early, harder to maintain</li></ul><p>Use this rule:</p><h3>If it is part of the same purchase, it is part of the same name</h3><p>If every customer who buys the platform uses the control plane, you are not naming a separate product. You are naming a surface.</p><p>That is why “Platform” as a name for the UI is often a mistake. It is too vague and sounds like a category, not an experience.</p><p>Good control plane labels are:</p><ul><li>Concrete (users know what it is)</li><li>Low-drama (does not steal attention from the master brand)</li><li>Stable (still true as features expand)</li></ul><p>“Control Plane” can work well for technical audiences because it maps to a known concept. [1]<br>“Console” works well when you want mainstream clarity because people already associate it with management and configuration. [2][3]</p><h3>Step 3: the decision framework (the one-page version)</h3><p>Answer these in order. Do not brainstorm names until you do.</p><h3>A) Audience and buyer</h3><ul><li>Is the platform buyer the same as the control plane daily user?</li><li>Is this purchased together, or separately?</li></ul><h3>B) Product boundaries</h3><ul><li>Can the platform exist without the control plane?</li><li>Can the control plane exist without the platform?</li><li>Do you plan separate pricing, packaging, or SKUs?</li></ul><h3>C) Risk of confusion</h3><ul><li>Will two different names create “what do I log into?” support load?</li><li>Will it fragment SEO and word-of-mouth?</li></ul><h3>D) Long-term portfolio</h3><ul><li>Are you building one system with modules, or multiple standalone products?</li></ul><p><strong>Default recommendation for most startups:</strong><br>Use a master brand and add a descriptor for the control plane. This is the master brand-with-descriptor end of the brand relationship spectrum, and it is usually the least confusing place to start. [7]</p><h3>Why internal codenames should stay internal</h3><p>Codenames are useful because they reduce coordination cost inside the team.</p><p>They become harmful when they leak, because they increase cognitive cost outside the team.</p><p>Leak paths are predictable:</p><ul><li>Repo names and README files copied into docs</li><li>Screenshots in launch posts</li><li>UI labels that accidentally ship</li><li>Support and sales using internal words in customer conversations</li></ul><p>Once a codename is visible externally, it starts competing with your real name. Then you have two brands, one intentional and one accidental.</p><h3>Codename hygiene: a practical playbook</h3><p>This is the part most teams skip. Do not skip it.</p><ol><li><strong>Create a single source of truth for public names</strong><br>A short doc: platform name, control plane label, module names, and “do not use” words.</li><li><strong>Treat codenames like secrets</strong><br>Not because they are confidential, but because they are confusing.</li><li><strong>Block codenames in customer-facing surfaces</strong></li></ol><ul><li>UI strings</li><li>Docs</li><li>Marketing pages</li><li>API URLs</li><li>Error messages</li></ul><ol><li><strong>Add an automated check</strong><br>A simple CI linter that fails if forbidden strings appear in docs or UI copy.</li><li><strong>Make screenshots a release artifact</strong><br>Before posting screenshots, quickly scan for internal labels.</li><li><strong>If you must use a codename, make it obviously internal</strong><br>Avoid anything that sounds like a polished product.</li><li><strong>Decide whether a codename can ever become public</strong><br>If yes, treat it like a real naming exercise: legal, trademark, domain, and pronunciation.</li></ol><h3>A concrete example: Findry and its Control Plane</h3><p>In one of my products, we chose:</p><ul><li><strong>Findry</strong> as the platform name</li><li><strong>Findry Control Plane</strong> as the control UI label</li><li>A separate internal codename for early development that never appears publicly</li></ul><p>Why it worked:</p><ul><li>It preserved one master brand in customer conversations.</li><li>It made the UI label self-explanatory.</li><li>It prevented accidental rebranding from internal language.</li></ul><p>The goal is boring consistency. Boring is good. Boring scales.</p><h3>The litmus test</h3><p>If a new customer can answer these in five seconds, you are winning:</p><ul><li>What is the product called?</li><li>Where do I log in to manage it?</li><li>What words should I search for when I need help?</li></ul><p>If they cannot, you do not have a naming problem. You have an architecture problem.</p><h3>References</h3><p>[1] Kubernetes Documentation, “Kubernetes Components” (control plane vs worker nodes and core components): <a href="https://kubernetes.io/docs/concepts/overview/components/">https://kubernetes.io/docs/concepts/overview/components/</a><br>[2] AWS Documentation, “What is the AWS Management Console?”: <a href="https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html">https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html</a><br>[3] Google Cloud, “Cloud Management Console”: <a href="https://cloud.google.com/cloud-console">https://cloud.google.com/cloud-console</a><br>[4] Google Cloud Documentation, “Manage your Google Cloud resources” (mentions using the Google Cloud console): <a href="https://docs.cloud.google.com/resource-manager/docs/manage-google-cloud-resources">https://docs.cloud.google.com/resource-manager/docs/manage-google-cloud-resources</a><br>[5] The Branding Journal, “What is Brand Architecture?”: <a href="https://www.thebrandingjournal.com/2022/01/brand-architecture/">https://www.thebrandingjournal.com/2022/01/brand-architecture/</a><br>[6] Qualtrics, “The Complete Guide to Brand Architecture” (branded house model overview): <a href="https://www.qualtrics.com/articles/strategy-research/brand-architecture/">https://www.qualtrics.com/articles/strategy-research/brand-architecture/</a><br>[7] California Management Review (UC Berkeley), Aaker &amp; Joachimsthaler, “The Brand Relationship Spectrum: The Key to the Brand Architecture Challenge”: <a href="https://cmr.berkeley.edu/2000/08/42-4-the-brand-relationship-spectrum-the-key-to-the-brand-architecture-challenge/">https://cmr.berkeley.edu/2000/08/42-4-the-brand-relationship-spectrum-the-key-to-the-brand-architecture-challenge/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e2b4b18b8a44" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/naming-your-platform-vs-your-control-plane-and-keeping-codenames-from-escaping-e2b4b18b8a44">Naming Your Platform vs Your Control Plane (and keeping codenames from escaping)</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Incorporating a Startup: Delaware C-Corp, Atlas vs Clerky, and the Checklist That Saves You Later]]></title>
            <link>https://medium.com/kuldeep/incorporating-a-startup-delaware-c-corp-atlas-vs-clerky-and-the-checklist-that-saves-you-later-2c50280725f2?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/2c50280725f2</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[founders]]></category>
            <category><![CDATA[startup]]></category>
            <category><![CDATA[company-incorporation]]></category>
            <category><![CDATA[stripe]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Tue, 27 Jan 2026 18:35:40 GMT</pubDate>
            <atom:updated>2026-01-27T22:44:24.386Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7tXRwcJCAVRTGNWlacaF-Q.png" /><figcaption>Incorporating Your Startup</figcaption></figure><h3>Incorporation is not a trophy. It is an operational control.</h3><p>Most founders treat incorporation like a ceremonial step: “We formed a company. Cool. Next.”</p><p>That is how you end up with:</p><ul><li>equity that was “promised” but not actually issued,</li><li>an 83(b) deadline that quietly detonates later,</li><li>contracts signed by the wrong entity,</li><li>and compliance mail that looks official but is not.</li></ul><p>Incorporation is best understood as the moment you turn your startup from a loose collaboration into a legally consistent system. Think of it like setting up the base layer of your stack. Boring, foundational, and expensive to redo later.</p><p>This post is the playbook I wish every founder had before clicking “start company.”</p><p>(Quick note: this is not legal or tax advice. It is a founder-oriented operating guide. If you have edge cases, talk to a qualified attorney or tax pro.)</p><h3>Step 0: Should you incorporate right now?</h3><p>Incorporate now if any of these are true:</p><ul><li>You are taking outside investment soon (SAFE, note, priced round).</li><li>You are issuing equity to anyone (cofounders, early hires, advisors).</li><li>You are signing meaningful contracts (enterprise customers, manufacturing, long-term leases).</li><li>You want clean liability separation between you and the business.</li></ul><p>Wait (or at least slow down) if:</p><ul><li>You are still validating whether the idea should exist.</li><li>You have no revenue, no customers, no team, and no imminent fundraising.</li><li>You are doing a consulting-style business where an LLC might be the better fit.</li></ul><p>A practical rule: Incorporate when you need the company to own things (IP, contracts, equity) and when other people need to trust the structure.</p><h3>Step 1: Entity choice in one paragraph</h3><p>Venture-backed or venture-scale startups usually end up as a <strong>Delaware C-Corporation</strong> because investors expect it and the legal framework is predictable. Stripe Atlas explicitly positions itself around forming either a Delaware C-Corp or LLC, with the “startup default” often being the C-Corp path. (<a href="https://docs.stripe.com/atlas">Stripe Docs</a>)</p><p>LLCs can be great for cash-flow businesses and simpler ownership, but they get messy when you want standard venture financing, option plans, and lots of shareholders.</p><h3>Step 2: Delaware realities you should know (the recurring stuff)</h3><p>If you are a Delaware corporation, you have an annual rhythm:</p><ul><li><strong>Annual report and franchise tax are due by March 1</strong> for domestic corporations. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li><li>The <strong>annual report filing fee is $50</strong> for non-exempt domestic corporations. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li><li>Franchise tax has multiple calculation methods. Delaware lists <strong>minimum tax of $175</strong> under the Authorized Shares method, and <strong>$400 minimum</strong>under the Assumed Par Value Capital method. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li><li>Miss the deadline and Delaware can add penalties and interest (they list a $200 penalty for not filing the annual report on time and interest at 1.5% per month on unpaid tax). (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li></ul><p>Also, Delaware requires a <strong>registered agent</strong>. That is a real ongoing cost, not a one-time checkbox.</p><p>One more founder-saving tip: Delaware warns about <strong>deceptive solicitations</strong>that look official and ask for money to file “minutes” or “records.” Delaware calls out a specific deceptive mailer pattern on its franchise tax page. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</p><h3>Step 3: Atlas vs Clerky (the comparison founders actually need)</h3><p>There are many ways to incorporate. Two common founder-friendly paths are <strong>Stripe Atlas</strong> and <strong>Clerky</strong>.</p><h3>Stripe Atlas: the bundled “formation-to-operating” path</h3><p>Atlas pricing is <strong>$500 one-time</strong>, and Stripe lists what that includes: Delaware incorporation (with next-day expedited processing and state filing fees), EIN, founder equity issuance and share purchase, and 83(b) filing, plus templates and perks. (<a href="https://stripe.com/atlas">Stripe</a>)<br>Atlas also includes your <strong>first year of registered agent service</strong>, then lists <strong>$100 annually after your first year</strong> if you keep Atlas as your registered agent. (<a href="https://stripe.com/atlas">Stripe</a>)<br>Stripe also states clearly that Atlas is not a law firm and does not provide legal, tax, or accounting advice. (<a href="https://stripe.com/atlas">Stripe</a>)</p><p>Atlas tends to be strong when you want:</p><ul><li>speed,</li><li>fewer decisions,</li><li>a guided workflow that covers the formation basics cleanly.</li></ul><h3>Clerky: the modular startup legal paperwork workbench</h3><p>Clerky’s pricing page shows a <strong>Pay Per Use option at $427</strong> and a <strong>Company Lifetime Package at $819</strong>. (<a href="https://www.clerky.com/pricing">Clerky</a>)<br>Clerky also states they typically return the filed certificate of incorporation within <strong>2–3 business days</strong>. (<a href="https://www.clerky.com/pricing">Clerky</a>)<br>Their pricing details explicitly include Delaware expedited filing fees and the first-year registered agent fee, plus reminders. (<a href="https://www.clerky.com/pricing">Clerky</a>)</p><p>Clerky tends to be strong when:</p><ul><li>you want to “stay on rails” for startup-standard documents,</li><li>you value modularity for fundraising, hiring, and maintenance paperwork over time,</li><li>you want a system that feels like a startup legal ops toolkit.</li></ul><h3>Practical decision shortcut</h3><ul><li>Pick <strong>Atlas</strong> if you want a bundled experience: form the company, get EIN, issue founder equity, file 83(b), and move on. (<a href="https://stripe.com/atlas">Stripe</a>)</li><li>Pick <strong>Clerky</strong> if you want a modular legal-document workspace that you can keep using across more workflows. (<a href="https://www.clerky.com/pricing">Clerky</a>)</li></ul><h3>Step 4: The post-incorporation checklist (this is where founders get hurt)</h3><p>Incorporation creates the entity. It does not magically make your company “clean.” The cleanup is the work.</p><p>Here is the checklist I recommend treating as non-optional.</p><h3>A) Governance and foundational docs</h3><ul><li>Bylaws adopted (or operating agreement for LLC).</li><li>Initial board consent signed.</li><li>Officer appointments documented.</li><li>Stock ledger started (even if it is a simple cap table tool).</li></ul><h3>B) Founders’ equity issued correctly</h3><p>If you are a C-Corp, founders usually purchase restricted stock and the company issues it under board approval. Atlas explicitly includes founder equity issuance and share purchase as part of the flow. (<a href="https://stripe.com/atlas">Stripe</a>)</p><p>This matters because “we agreed 50/50 in a Google Doc” is not ownership.</p><h3>C) File 83(b) on time (seriously)</h3><p>If founders receive restricted stock (stock that vests over time), the 83(b) election is one of the most time-sensitive steps in early startup life.</p><p>The IRS states the election must be filed <strong>no later than 30 days after the transfer</strong>. (<a href="https://www.irs.gov/pub/irs-pdf/f15620.pdf?utm_source=chatgpt.com">IRS</a>)<br>Stripe’s Atlas support content also repeats the “within 30 calendar days” requirement in the startup context. (<a href="https://support.stripe.com/questions/atlas-filing-your-83%28b%29-election-using-auto-83%28b%29?utm_source=chatgpt.com">Stripe Support</a>)</p><p>Atlas advertises 83(b) election filing as included. (<a href="https://stripe.com/atlas">Stripe</a>)</p><p>Even if a service helps, you still own the risk. Make “83(b) done” a Day 1 priority, not a “later this week” task.</p><h3>D) IP assignment and invention paperwork</h3><ul><li>Founders assign relevant IP to the company.</li><li>Contractors sign invention assignment agreements.</li><li>If you used a dev shop or freelancer early, clean this up before fundraising.</li></ul><h3>E) Taxes, banking, and operational basics</h3><ul><li>EIN received (Atlas includes EIN acquisition in the workflow). (<a href="https://stripe.com/atlas">Stripe</a>)</li><li>Business bank account opened.</li><li>Bookkeeping started early enough to not hate yourself later.</li></ul><h3>F) Compliance calendar</h3><p>Put these on a recurring reminder:</p><ul><li>Delaware annual report and franchise tax deadline (March 1). (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li><li>Registered agent renewal cost.</li><li>Your “home state” obligations if you operate outside Delaware (foreign qualification often applies, and it is separate from Delaware formation).</li></ul><h3>Common incorporation mistakes, in plain language</h3><ol><li><strong>Incorporating too early<br></strong>You waste money and create compliance drag before you even know the business should exist.</li><li><strong>Not issuing equity properly<br></strong>This becomes painful when you add a cofounder, raise a SAFE, or sell the company.</li><li><strong>Missing the 83(b) window<br></strong>The IRS 30-day rule is strict. Treat it like a production outage. (<a href="https://www.irs.gov/pub/irs-pdf/f15620.pdf?utm_source=chatgpt.com">IRS</a>)</li><li><strong>Forgetting Delaware’s annual obligations<br></strong>March 1 sneaks up on founders every year. Delaware is not shy about penalties. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li><li><strong>Paying random “official-looking” mail<br></strong>Delaware literally warns you about deceptive solicitations. Assume anything that arrives by mail is guilty until proven innocent. (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li></ol><h3>A simple incorporation workflow that works</h3><p>Here’s a clean sequence that avoids most founder mistakes:</p><ol><li>Decide: Delaware C-Corp vs LLC (based on fundraising and equity plans). (<a href="https://docs.stripe.com/atlas">Stripe Docs</a>)</li><li>Choose your formation path: Atlas (bundled) or Clerky (modular). (<a href="https://stripe.com/atlas">Stripe</a>)</li><li>Incorporate and obtain EIN. (<a href="https://stripe.com/atlas">Stripe</a>)</li><li>Complete post-incorporation setup: board consent, founder equity issuance, IP assignment, cap table. (<a href="https://stripe.com/atlas">Stripe</a>)</li><li>File 83(b) within 30 days if applicable. (<a href="https://www.irs.gov/pub/irs-pdf/f15620.pdf?utm_source=chatgpt.com">IRS</a>)</li><li>Put Delaware compliance on autopilot (annual report and franchise tax by March 1). (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</li></ol><h3>What I would publish next in this series</h3><ul><li>Founder equity 101: restricted stock, vesting, cliffs, and what to pick when you have no idea</li><li>Cap tables without tears: how to avoid “spreadsheet cap table collapse”</li><li>SAFEs for founders: what actually matters in the terms</li></ul><p>Delaware franchise tax: why the default method can surprise you, and how to think about it (<a href="https://corp.delaware.gov/frtax/">Delaware Corporations Division</a>)</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2c50280725f2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/incorporating-a-startup-delaware-c-corp-atlas-vs-clerky-and-the-checklist-that-saves-you-later-2c50280725f2">Incorporating a Startup: Delaware C-Corp, Atlas vs Clerky, and the Checklist That Saves You Later</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[MCP + Context Engineering: From Prompts to Protocols that Ship Real Work]]></title>
            <link>https://medium.com/kuldeep/mcp-context-engineering-from-prompts-to-protocols-that-ship-real-work-99a9e61962a4?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/99a9e61962a4</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[openai]]></category>
            <category><![CDATA[context-engineering]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Fri, 14 Nov 2025 15:28:07 GMT</pubDate>
            <atom:updated>2025-11-14T15:27:51.637Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><p>Prompt engineering got us moving, but context engineering is how teams ship outcomes. Over the last year I’ve watched the Model Context Protocol (MCP) turn messy, one‑off integrations into a standard way to connect assistants to data and tools. MCP gives you a predictable port; think “USB‑C for AI”; and context engineering gives you a playbook for what to send through it: ground truth, guardrails, and just enough state to finish the job. This post shares how I approach the pair: what MCP is, how context actually flows, and a pattern that keeps agents reliable at scale.</p><p><strong>What MCP is (and why it matters)</strong></p><p>MCP is an open standard for connecting AI applications to external systems without bespoke glue code for each app or dataset. In MCP terms, servers expose three things: tools (callable functions), resources (data you can read), and prompts (reusable, parameterized instructions). Clients: your IDE, desktop assistant, or web app discover what’s available and request exactly the context they need. The result is a clean separation of concerns: models focus on reasoning, while MCP handles discovery, transport, and permissions. [1][2][3]</p><p><strong>Context engineering in practice</strong></p><p>Context engineering treats the context window like a scarce budget. Instead of dumping everything into a prompt, the goal is to route just‑in‑time evidence: who the user is, what they’re doing, and the canonical facts they’re allowed to see. In most real systems, that means retrieval‑augmented generation (RAG) for facts, structured prompts for policy and voice, and slim task memory so agents don’t lose the plot. The combination reduces hallucination risk and keeps responses traceable to source material. [6]</p><p><strong>A simple architecture that scales</strong></p><p>The pattern I’ve used and seen work looks like this. A client (say, an IDE or desktop assistant) connects to one or more MCP servers. Each server advertises tools (e.g., “create_ticket”, “get_customer”), resources (e.g., “kb://refund-policy”, “db://orders/123”), and prompts (e.g., “refund‑eligibility-check”). At run time, the client assembles a task‑specific context: a lightweight system message, a few retrieved documents, and a plan that names which tools are allowed. Because capabilities are declared and typed up front, observability and safety controls are far easier to implement. [1][2][3][4]</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*hqiSaS5ZTkZHrh8ZfV-0OQ.png" /></figure><p><strong>MCP + context engineering, step‑by‑step</strong></p><p><strong>1) **Define the contract.**</strong> On the server side, publish tools with clear schemas, stable names, and input/output validation. Expose resources by URI and group prompts as reusable templates so clients can parameterize them. Add metadata that a policy engine can reason about: PII categories, permissions, scopes, and rate limits. [2]<br><strong>2) **Plan the context.**</strong> Decide what must be in the window every time (policy, tone, persona) and what should be retrieved on demand (facts, IDs, recent activity). This is where RAG and caching earn their keep; fetched context should be small, recent, and attributable. [6]<br><strong>3) **Run with bounded autonomy.**</strong> Give the agent a step budget and an allowlist of tools. Log each tool call, the retrieved resources, and the reasoning breadcrumb so humans can audit later. Keep write actions behind an approval gate until the success rate is boringly high.<br><strong>4) **Secure the loop.**</strong> Treat inputs and tools as untrusted by default. Sanitize retrieved content, sandbox tool execution, and monitor for injection, insecure output handling, and excessive agency. [7]<br><strong>5) **Measure and iterate.**</strong> Track task success, handoff reasons, cycle time, and cost per task (model + tools + human minutes). Add every near‑miss to the evaluation set so regressions get caught in CI.</p><p><strong>Two concrete examples</strong></p><p><strong>**Support triage.**</strong> The assistant classifies inbound cases, checks entitlement via a tool, retrieves one or two policy resources, and drafts a resolution note using a prompt template. High‑risk intents (refunds, legal claims) automatically escalate to human review. Because everything is declared in MCP; the tools, the policy documents, the prompts; auditing is a matter of reading the trace. Teams see faster handle time without sacrificing control. [2]</p><p><strong>**Developer productivity.**</strong> Inside an IDE, the client connects to a code‑aware MCP server. Resources expose file contents and dependency metadata; tools open a branch, run tests, or raise a PR; prompts standardize commit messages and review checklists. The agent plans a few steps, retrieves only the relevant files, and calls whitelisted tools under a strict step budget. It feels like help from a disciplined teammate instead of a black box. [3][4][5]</p><p><strong>Rollout plan (30/60/90)</strong></p><p><strong>**Days 0–30:</strong> Prove the plumbing.** Stand up a single MCP server with two tools, two resource families, and one prompt pack. Ship a tiny task with a hard step budget and read‑only tools; build a golden‑task suite and capture traces.<br><strong>**Days 31–60:</strong> Make it trustworthy.** Add an adjacent task, expand tools to four, and wire in a policy engine that enforces scopes and rate limits. Introduce adversarial tests (tainted content, strange arguments) and a rollback runbook. [7]<br><strong>**Days 61–90:</strong> Prove value.** Turn on assisted execution for a subset of users and publish a value‑plus‑risk scorecard: success rate, handoffs, cycle time, cost per task, incidents/near‑misses. Only then consider lifting write gates.</p><p><strong>Where MCP is heading</strong></p><p>MCP isn’t theory; it’s already powering real clients, including desktop assistants that connect to local servers for file access and other integrations. Vendors are adopting it because “integrate once, reuse everywhere” is cheaper than N bespoke connectors per app. Expect richer capabilities around session state, enterprise identity, and standardized observability so teams can trace actions across servers. That evolution makes context engineering more valuable, not less. [4][5]</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/864/1*s5Flu_LfBfa1_olAFxr1yg.png" /></figure><p><strong>References</strong></p><p>[1] Model Context Protocol (overview): <a href="https://modelcontextprotocol.io/">https://modelcontextprotocol.io/</a></p><p>[2] MCP Specification — Tools &amp; Prompts (server): <a href="https://modelcontextprotocol.io/specification/2025-06-18/server/tools">https://modelcontextprotocol.io/specification/2025-06-18/server/tools</a> ; <a href="https://modelcontextprotocol.io/specification/2025-06-18/server/prompts">https://modelcontextprotocol.io/specification/2025-06-18/server/prompts</a></p><p>[3] Claude Docs — Model Context Protocol: <a href="https://docs.claude.com/en/docs/mcp">https://docs.claude.com/en/docs/mcp</a></p><p>[4] Connect to local MCP servers (Claude Desktop): <a href="https://modelcontextprotocol.io/docs/develop/connect-local-servers">https://modelcontextprotocol.io/docs/develop/connect-local-servers</a></p><p>[5] Anthropic — Introducing the Model Context Protocol: <a href="https://www.anthropic.com/news/model-context-protocol">https://www.anthropic.com/news/model-context-protocol</a></p><p>[6] Lewis et al., “Retrieval‑Augmented Generation for Knowledge‑Intensive NLP,” NeurIPS 2020: <a href="https://proceedings.neurips.cc/paper/2020/file/6b493230205f780e1bc26945df7481e5-Paper.pdf">https://proceedings.neurips.cc/paper/2020/file/6b493230205f780e1bc26945df7481e5-Paper.pdf</a></p><p>[7] OWASP Top 10 for LLM Applications: <a href="https://owasp.org/www-project-top-10-for-large-language-model-applications/">https://owasp.org/www-project-top-10-for-large-language-model-applications/</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=99a9e61962a4" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/mcp-context-engineering-from-prompts-to-protocols-that-ship-real-work-99a9e61962a4">MCP + Context Engineering: From Prompts to Protocols that Ship Real Work</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Rise of AI Agents in Business Operations]]></title>
            <link>https://medium.com/kuldeep/the-rise-of-ai-agents-in-business-operations-89b681df7f2d?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/89b681df7f2d</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Thu, 13 Nov 2025 01:07:24 GMT</pubDate>
            <atom:updated>2025-11-13T01:07:24.290Z</atom:updated>
            <content:encoded><![CDATA[<p><em>By Kuldeep Chowhan, technology executive and founder of a stealth startup; previously with Walmart and Expedia Group.</em></p><p><strong>Thesis in one line:</strong> Copilots accelerate people; agents complete multi-step work. The deployments that win <em>constrain</em>autonomy, instrument every step, and define crisp human handoffs. Treat agents like workflow participants with SLAs, not magic.</p><h3>Why agents and why now?</h3><p>The first wave of AI made individuals faster at drafting, summarizing, and searching. Real operational value, though, tends to be trapped in messy handoffs across systems and teams. Agents address that by planning, calling tools, and finishing tasks end-to-end under supervision. In practice, bounded autonomy; tight scopes, explicit policies, and observable behavior, turns promise into dependable throughput.</p><h3>Where agents fit (and where they don’t)</h3><p>Across organizations I’ve led or advised or observed, agents shine on <strong>multi-step, tool-heavy, high-volume</strong> tasks with clear success criteria. Customer operations benefit from automated triage, entitlement checks, and CRM updates; finance teams offload invoice matching and reconciliations; supply chains manage exceptions and send structured supplier outreach; SREs run safe, read-only runbooks. On the other hand, ambiguous, high-stakes decisions that set customer terms (credit, pricing, eligibility) stay human-approved, with the agent preparing evidence and a recommended action. A useful test: would you hand this to a new hire with a precise checklist?</p><h3>The enterprise agent in seven parts</h3><p>A production-grade agent is seven cooperating components. <strong>Planner</strong> interleaves reasoning and acting (plan → act → observe → update) instead of jumping straight to output. <strong>Tools</strong> are whitelisted, strongly typed, rate-limited, and spend-guarded so “tool use” behaves deterministically. <strong>Retrieval &amp; context</strong>, <strong>memory</strong>, <strong>policy checks</strong>, <strong>observability</strong>, and <strong>human-in-the-loop (HIL)</strong> complete the stack and make the system auditable.</p><p>This model turns black-box intelligence into something operations can run. The planner chooses the next step; tools do bounded work; policies enforce permissions and data hygiene. Observability streams traces, inputs/outputs, and costs; HIL rules define when to escalate. When any pillar is missing, reliability suffers.</p><h3>Safety and security: design for failure</h3><p>Agents mix LLM behavior with tool execution, so the threat surface includes both untrusted inputs and well-intentioned tools doing the wrong thing perfectly. Teams have had success with <strong>containment first</strong>: sandboxed tools, scoped credentials, and explicit allow/deny lists. Add <strong>input hygiene</strong> (strip active content, canonicalize text), <strong>adversarial evaluations</strong> (prompt-injection patterns, tainted retrieval), and <strong>incident playbooks</strong> with rollback rehearsed. Security isn’t a feature; it’s an operating discipline with drills and evidence.</p><h3>Four patterns that keep paying off</h3><p><strong>1) Support triage &amp; resolution drafting.</strong><br>Agents classify cases, check entitlements, locate policy answers, update CRM, and schedule follow-ups. Guardrails include source-grounding, tone filters, HIL for refunds or legal claims, fatigue caps, and bias checks on routing. Results show fewer escalations and faster cycle times on common intents.</p><p><strong>2) Product Software runbook execution.</strong><br>Agents read logs, correlate known errors, draft remediation steps, open change requests, and prepare rollback plans. Production stays read-only; any change needs human approval; tool calls are rate-limited; incidents feed new tests into the eval suite. On-call gets cleaner and time-to-mitigation drops.</p><p><strong>3) Supply-chain exception handling.</strong><br>Agents detect late shipments, propose reorder quantities within thresholds, and notify suppliers with context. Hard caps and tolerance windows prevent overreach; order creation requires dual-control approvals; a rollback macro reverses bad proposals. The pattern scales across categories once thresholds and evidence trails are in place.</p><h3>Operate agents like mission-critical workflows</h3><p>The metrics that matter mirror any operational service. <strong>Task success rate</strong> (end-to-end without human correction), <strong>handoff rate</strong> with reasons (safety, uncertainty, policy, cost), <strong>cycle time</strong>, <strong>cost per task</strong> (model + tool/API + review minutes), <strong>incident rate/MTTR</strong>, and <strong>operator trust</strong>. For customer-facing flows, track <strong>CSAT/NPS</strong> on assisted interactions. Time-to-first demo is nice; unit economics over a 30-day window is decisive.</p><p>A unit-economics dashboard is non-negotiable. Tokens spend and API costs are visible, but human review minutes dominate early. Step budgets and smarter tool selection drive cost down as reliability improves. This is how teams avoid the “cool demo, costly operations” trap.</p><h3>A 30/60/90 plan that moves from demo to dependable</h3><p><strong>Days 0–30: Prove the loop, bound the risk.</strong><br>Pick one high-volume task tied to a single system of record. Stand up the seven-part runtime with two whitelisted tools and a strict <strong>step budget</strong> (for example, ≤12 actions per task). Build a <strong>golden task</strong> set; run daily regressions; gate any write action behind HIL. Shadow users to collect traces before exposing the agent broadly.</p><p><strong>Days 31–60: From functioning to trustworthy.</strong><br>Add one adjacent task and two more tools while keeping the same guardrails. Instrument cost and latency end-to-end; publish a per-task unit-economics view for leaders and operators. Introduce adversarial tests (tricky inputs, tainted retrieval), fix anything that breaks, and capture structured human feedback (approve/correct/reject + reason). Draft an incident playbook with severity levels, on-call, and rollback steps.</p><p><strong>Days 61–90: Prove value and resilience.</strong><br>Enable <strong>assisted execution</strong> for a subset of users (opt-in), with HIL and rollback. Report a weekly <strong>value-and-risk scorecard</strong>: success, handoffs, cycle time, cost per task, incidents, and near-misses. Run a controlled experiment (A/B or stepped rollout) to quantify throughput/quality impact. Decide to scale, hold, or halt based on both business results and residual risk.</p><h3>Governance that doesn’t slow you down</h3><p>Lightweight governance travels with the work, not against it. A <strong>use-case register</strong> names purpose, tools, data, risk class, HIL rules, and owners; one page that defuses audit friction later. For anything customer-facing or rights/safety-impacting, raise the floor: HIL required, eval suite in CI, post-deployment monitoring, and quarterly incident drills. Align controls to recognized risk-management frameworks so evidence is reusable across teams and audits.</p><h3>Common pitfalls (and simple fixes)</h3><p><strong>Unbounded autonomy</strong> guarantees surprises. Fix with tool whitelists, permission scopes, and step budgets. <strong>No crisp finish line</strong> yields vague wins; write success criteria as if QA had to score the output. <strong>Treating guardrails as one-and-done</strong> misses a moving target; keep red-teaming and regression evergreen. <strong>Measuring demos, not operations</strong> hide cost and risk; insist on success, handoffs, cost, incidents, and customer outcomes from day one.</p><h3>Bottom line</h3><p>Agents are ready for real work when designed for reality. Bounded autonomy, observable behavior, human judgment where it matters, and relentless measurement turn pilots into durable throughput and quality. Treated like teammates with SLAs and accountability, agents repay the trust with fewer escalations and more consistent outcomes. That’s how teams graduate from prototypes to production; without betting the business on unchecked autonomy.</p><h3>References</h3><p>NIST AI Risk Management Framework site and Generative AI Profile (AI 600–1).</p><p>ISO/IEC 42001 (AI management systems) and ISO/IEC 23894 (AI risk management).</p><p>OWASP Top 10 for LLM Applications.</p><p>ReAct and Toolformer research on reasoning-plus-acting and tool use.</p><p>AgentBench and WebArena benchmarks for realistic agent tasks.</p><p>OMB M-24–10 governance memo for rights and safety impacting AI uses.</p><p>Controlled study on GitHub Copilot task-time improvement.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89b681df7f2d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/the-rise-of-ai-agents-in-business-operations-89b681df7f2d">The Rise of AI Agents in Business Operations</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Expedia uses DynamoDB and ElasticCache to build a Real-Time Analytics system]]></title>
            <link>https://medium.com/kuldeep/how-expedia-uses-dynamodb-and-elasticcache-to-build-a-real-time-analytics-system-5828a1f1997c?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/5828a1f1997c</guid>
            <category><![CDATA[dynamodb]]></category>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Sat, 29 Oct 2016 05:15:01 GMT</pubDate>
            <atom:updated>2016-10-29T05:19:57.757Z</atom:updated>
            <content:encoded><![CDATA[<p>How Expedia uses DynamoDB and ElasticCache to build a Real-Time Analytics system</p><p>Last year during AWS re:invent 2015, I presented on how Expedia uses a DynamoDB and ElasticCache to build a Real-Time Analytics system.</p><p>You can view the video @</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2Fie4dWGT76LM%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3Die4dWGT76LM&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2Fie4dWGT76LM%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/9cc5ea9aae542204cda1205883aabfe7/href">https://medium.com/media/9cc5ea9aae542204cda1205883aabfe7/href</a></iframe><p>If you want to know more about this, you can reach me on twitter @this_is_kuldeep</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5828a1f1997c" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/how-expedia-uses-dynamodb-and-elasticcache-to-build-a-real-time-analytics-system-5828a1f1997c">How Expedia uses DynamoDB and ElasticCache to build a Real-Time Analytics system</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Docker usage in Expedia in Production]]></title>
            <link>https://medium.com/kuldeep/docker-usage-in-expedia-in-production-20f8af2ea458?source=rss----b16783ca6932---4</link>
            <guid isPermaLink="false">https://medium.com/p/20f8af2ea458</guid>
            <category><![CDATA[aws]]></category>
            <category><![CDATA[docker]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <dc:creator><![CDATA[Kuldeep Chowhan]]></dc:creator>
            <pubDate>Sat, 29 Oct 2016 05:09:57 GMT</pubDate>
            <atom:updated>2016-10-29T05:20:49.855Z</atom:updated>
            <content:encoded><![CDATA[<p>Docker usage in Expedia in Production</p><p>I presented in one of the docker webinars on How Expedia uses Docker in production.</p><p>You can view it @</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FSZ9TDc-4Kdg%3Ffeature%3Doembed&amp;url=http%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DSZ9TDc-4Kdg&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FSZ9TDc-4Kdg%2Fhqdefault.jpg&amp;key=d04bfffea46d4aeda930ec88cc64b87c&amp;type=text%2Fhtml&amp;schema=youtube" width="640" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/cba7c30ea97375f0159be649205031ee/href">https://medium.com/media/cba7c30ea97375f0159be649205031ee/href</a></iframe><p>If you want to know more about this, you can reach me on twitter @this_is_kuldeep</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20f8af2ea458" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kuldeep/docker-usage-in-expedia-in-production-20f8af2ea458">Docker usage in Expedia in Production</a> was originally published in <a href="https://medium.com/kuldeep">Kuldeep Chowhan ‘s Blog</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>