The Zag on Agentic Scale: Why We Kept Our Editorial Logic Hand-Coded While Salesforce Built Agentforce

We spent the better part of last spring trying to make our publishing pipeline think for itself.

It was a classic developer’s temptation. We had built a sprawling network of micro-services to parse, format, and distribute B2B content across half a dozen social and professional platforms. Each platform, as anyone who has ever wrestled with an API knows, possesses its own delicate, easily offended temperament. LinkedIn wants clean paragraphs and hates external links; other channels demand precise image ratios and specific metadata structures.

Instead of writing another hundred lines of rigid conditional logic to handle these quirks, we decided to build an autonomous agentic layer. We gave a large language model access to our publishing APIs, handed it a set of style guides, and told it to “optimize and distribute.”

The result was a quiet disaster of context drift. Within a week, our clean, technical pieces began acquiring the distinct, oily sheen of generic marketing copy. The agent, attempting to “optimize for engagement” based on vague semantic instructions, started rewriting technical nomenclature to make it more “accessible.” A post about database sharding became a post about “unlocking growth.” (I still shudder slightly remembering the afternoon we found a draft where a precise explanation of postgres vacuuming had been translated into a metaphor about spring cleaning.)

We killed the project and went back to hand-coding our structural logic.

This tension—between the deterministic rigidity of traditional code and the slippery promise of autonomous agents—is no longer just a backend engineering debate. It has become the central battleground for enterprise software.

The Promise of the Autonomous Layer

During his keynote at Dreamforce, Salesforce CEO Marc Benioff made a familiar pitch for “Agentforce,” positioning it as the end of the DIY software integration era. The argument, as analyzed by Ben Thompson of Stratechery, is that the traditional enterprise software stack is too expensive, too fragile, and too reliant on army-sized integration teams.

Salesforce’s solution is to replace custom integration code with autonomous agents that navigate the enterprise data layer on their own. Instead of building custom APIs to connect your CRM to your marketing automation tool, you simply let an agent “understand” the data and act accordingly.

It is a seductive vision. But it glosses over the fundamental reality of how systems actually interact when there is no human in the loop to correct the course.

In our own limited sandbox, we found that letting off-the-shelf agents handle distribution workflows introduces a compounding series of errors. When you replace a deterministic line of code—like if platform == "linkedin": remove_links()—with a semantic instruction like “make sure this post matches the formatting guidelines of the target platform,” you are trading a predictable failure mode for an unpredictable one.

An API error is loud and easy to debug. It throws a 400 Bad Request, your error logs light up, and you fix the syntax. Context drift is quiet. It doesn’t trigger an error log. The post goes live, the API returns a 200 OK, but the actual substance of your message has been subtly degraded.

Why We Hand-Code Our Editorial Structure

When we rebuilt our publishing pipeline, we established a strict boundary between where the AI is allowed to play and where the code must remain absolute.

We use LLMs for raw translation tasks: taking a transcript and turning it into a structured summary, or extracting key pull quotes from a long-form article. These are tasks where semantic flexibility is an asset, not a liability.

But the moment that raw text enters our distribution pipeline, the AI is locked out. The structural logic is entirely hand-coded:

• Formatting Rules: The code strips, appends, and reformats text based on strict, regular-expression-driven rules. If a platform limits post length to a specific character count, we don’t ask an LLM to “shorten this gently.” We use a deterministic truncation function that we can test with 100% predictability.
• Routing Logic: Deciding which piece of content goes to which channel, and at what time, is governed by a relational database and a state machine. It is boring, rigid, and entirely reliable.
• Metadata Construction: Generating the precise JSON payloads required by various publishing APIs is handled by typed serialization classes.

This approach lacks the magical allure of “agentic orchestration.” You cannot pitch it to venture capitalists as a self-evolving system. But it has one overwhelming advantage: when a post fails to publish, we know exactly which line of code broke it within three seconds.

The Trade-off of the “No-Code” Illusion

The pitch for systems like Agentforce relies on the assumption that enterprise data is clean enough, and enterprise goals clear enough, for an LLM to navigate them without getting lost.

In practice, most enterprise data environments are historical graveyards of conflicting schemas, abandoned custom fields, and undocumented business logic. Expecting an autonomous agent to safely navigate this terrain without constant human supervision is a recipe for silent operational drift.

For a professional firm or a specialized publisher, the stakes of this drift are exceptionally high. Your brand is not built on the volume of content you distribute, but on the precision of your positioning. A single post that uses the wrong industry terminology or adopts an inappropriate tone can undo months of authority-building.

By keeping our structural logic hand-coded, we accept the burden of maintenance. When an API changes, we have to open our code editor and update our integration modules manually. It is tedious work. But it ensures that our distribution pipeline remains a faithful pipe, not an active participant that edits our thoughts on their way to the reader.

The lesson we took from our experiments is simple: use AI for its strengths—synthesis, draft generation, and semantic translation—but never cede control of the plumbing. Keep your infrastructure deterministic, your APIs hand-coded, and your logic visible. The alternative is a system that runs faster and faster, in a direction you didn’t intend, towards a destination you cannot predict.

This article was generated with the help of AI.