Agent Skills vs Python Scripts: A Developer's

Every new infrastructure layer arrives promising to simplify the one beneath it. Usually it does, and usually that simplification comes bundled with dependencies, pricing terms, and lock-in that the early adopters didn't think to read. That's not cynicism — that's the pattern. Which is why a recent tutorial from ZazenCodes developer Alex, walking through his shift from Python scripts to what he calls "agent skill workflows," is worth reading as something other than a productivity tip.

The technical argument is genuinely interesting. Alex's core claim: instead of writing a Python file and executing it with python script.py, write a markdown file with natural-language instructions and execute it with a coding agent like Claude Code or Codex. The markdown file becomes the script. The agent becomes the runtime.

"The way I'm doing that now," Alex explains, "is I'm writing a markdown file and then I'm executing that markdown with an agent. So the agent is looking at the English language in the markdown file and it is carrying out those tasks."

He's careful to say this isn't about AI versus no AI — he was already using AI to generate Python scripts. The shift is in how execution happens. The agent becomes the interface, not just the co-author.

What Agent Skills Actually Do

In Alex's setup, a "skill" is a markdown file with a name, a description, and a step-by-step workflow written in plain English. The agent reads the skill, identifies which one to trigger based on the user's request, and begins executing the steps. Where deterministic work is needed — parsing a CSV, running calculations, generating a chart — the skill instructs the agent to call an actual Python script. Where generative work is needed — summarizing a section, writing a caption, identifying a short-form clip — the agent handles it directly.

The result is a hybrid: Python handles the parts that need to be predictable; the agent handles the parts that benefit from flexibility. Alex demonstrates this with two examples — a "find clips" skill that extracts Instagram-worthy moments from YouTube transcripts, and an expense report skill that categorizes credit card statements, generates charts, and then spawns sub-agents to write narrative summaries of each section.

The expense report example is the more illustrative one. When Alex runs it, the skill triggers a Python script for the deterministic data processing, then instructs the agent to loop through each section of the generated report and enrich it with AI-written analysis. Three sub-agents spin up in parallel, each handling a different section, then their outputs get synthesized back into the final document.

"Look at how we're spawning all of these sub-agents," Alex says, with audible satisfaction. "That is pretty damn cool."

It is, actually.

The API Key Argument — and What It Skips

Alex makes much of one specific advantage: agent skills don't require their own API keys. A standalone Python script calling an LLM needs credentials and incurs direct costs per call. An agent skill piggybacks on whatever coding agent subscription you're already running.

"You can use your like subsidized coding agent to do all of the AI stuff," he says. "You can just piggyback on it for free."

Free is doing a lot of work in that sentence. The more precise version: the cost is already paid, elsewhere, in the subscription fee for the coding agent. This matters less if you're an individual developer running a few automations. It matters considerably more as usage scales, because the terms governing what counts as acceptable use of a coding agent subscription are written by the vendor, not the user, and they can change.

Claude's and Codex's current subscription tiers are structured around interactive developer use. Using the agent as a batch-processing runtime for dozens of recurring automated workflows is a different usage pattern — one that AI companies have both the contractual latitude and the commercial incentive to eventually meter separately. "Free because it's bundled" is a pricing state, not a pricing principle. The people who build financial workflows on this assumption and then discover a usage policy update in their inbox are going to have a bad quarter.

The Symlink Problem Is the Real Story

The most technically revealing moment in Alex's tutorial is also the most casually delivered. To make his skills available across both Claude Code and Codex, he creates symlinks — pointing each tool's skills directory to a single source file. He describes this as slightly crazy, then moves on.

He shouldn't move on. What he's describing is the absence of any standardized skill registry across coding agent platforms. Each tool has its own convention for where skills live, how they're named, and how they're discovered. His symlink solution works, but it's a workaround for a gap in the ecosystem, not a feature of it.

"I actually personally love the complexity of agent skills and coding agents," Alex admits, "and how we haven't quite figured it out yet — because as a developer it kind of gives me a chance to still have some kind of edge."

That's an honest thing to say. It's also a description of a window that closes. The history of developer tooling is the history of personal hacks getting absorbed into platform standards. When Anthropic, OpenAI, or a third party eventually introduces a formalized skill registry — with an official schema, a discovery protocol, a marketplace — the personal edge disappears. What replaces it is a set of terms of service, enforcement mechanisms, and probably tiered access. The developer who built their entire automation stack on symlinks and markdown conventions will spend a weekend migrating, or won't, and will watch their workflows break.

None of this means the approach is wrong. It means the current moment has a particular shape — informal, flexible, genuinely user-controlled — that future standardization will alter. Standards bodies don't tend to ask power users what they want to preserve.

The Non-Determinism Question Nobody Asked

There's one thread Alex introduces and declines to follow. He acknowledges that agent skill execution is non-deterministic — run the same skill twice, get outputs that differ. He frames the "surface area" of non-determinism as small, since the actual calculations happen in Python. But consider what he's demonstrating: an expense report that generates AI-written financial summaries and spending recommendations.

If that report is used in any professional context — tax preparation, reimbursement, financial review — the fact that it reads differently on different runs is not a minor inconvenience. It's a liability question. Which version of the report is authoritative? Who is responsible when the agent's "recommendation" section contains an error that influences a business decision? These aren't hypotheticals reserved for enterprise deployments; they're the natural endpoint of productivity tools that people actually use for real tasks.

Alex's demos use fake data, which is the right call for a tutorial. But the expense report skill he built is explicitly designed to process real credit card statements. The gap between "this is a cool demo" and "this is my actual financial workflow" is exactly the gap where accountability questions live, and right now there are no clear answers.

The Technical Case, Standing Alone

To be clear about what Alex gets right: the flexibility argument holds. Being able to type "find clips for the agent fleet video" instead of locating a file path, passing it as an argument, and running a script is a genuine quality-of-life improvement. The ability to iterate interactively mid-workflow — reviewing clip candidates, providing feedback, refining output — is something Python scripts structurally cannot offer without substantial additional engineering. The sub-agent orchestration pattern, where parallel agents process sections of a document independently, is genuinely novel and opens up approaches to document-level AI work that weren't accessible to most developers a year ago.

The trade-off Alex identifies — determinism for flexibility — is real and fairly characterized. His hybrid approach, where Python handles calculation and the agent handles generation, is a reasonable way to narrow the non-determinism surface.

What the tutorial doesn't examine is the governance layer underneath all of it: who controls the skill registry when it gets formalized, what the pricing looks like when the bundled model ends, and what it means to build financial workflows on infrastructure whose outputs you cannot reproduce on demand.

Those questions aren't Alex's job to answer. They are, however, the questions that will determine whether "agent skill workflows" becomes a durable pattern or a transitional one.

By Samira Barnes, Tech Policy & Regulation Correspondent