How We Engineer AI Products Without Revealing the Secret Sauce

There is a real tension in writing publicly about AI engineering. Say too little, and readers have little to go on when deciding whether the AI work behind a product is real. Say too much, and you hand competitors hard-won lessons. Or worse, you hand an attacker a map. At PDI, we have spent the past couple of years building AI into products used by fuel and convenience retailers, and we have landed on a working answer to that tension. This post is about the answer itself: how we decide what to share, and why the discipline behind that decision is the same discipline we apply when building our AI products. 

That last part is worth a closer look. In our experience, the habits that keep your secret sauce secret—governance, guardrails, review gates—are not PR hygiene layered on after the engineering is done. They are part of the engineering. 

Writing publicly about AI engineering means balancing two needs: giving readers enough detail to judge whether the work is real, and protecting proprietary methods, customer data, and security. One approach is to share architecture as patterns, describe failures generically, keep real customer data out of examples, and explain the reasoning behind decisions rather than exact configurations. The same habits that protect those details, such as structured intake, guardrails, and review, also shape how AI systems are designed. 

Why we talk about our AI work at all

The easy move would be silence. Nobody ever leaked a prompt by not publishing a blog post. But silence has costs we’re not willing to pay. Our customers run businesses where a bad automated decision touches real money at real stores, and they deserve to know how we think before they trust what we build. Teams evaluating AI want evidence that a company’s AI story is real. And frankly, we learned a lot from teams who wrote honestly about their own AI journeys. There’s a debt to pay forward. 

So the question was never whether to talk. It was how to talk usefully without giving away the things we learned the hard way.

The line we draw: share how we think, not how it works

Over time, we’ve converged on a small set of principles that guide our external content, from blog posts and conference talks to sales decks and even screenshots in support tickets: 

  1. Share the shape, not the settings: We will describe an architecture as a pattern (layers of isolation, a retrieval pipeline, an orchestration model) without naming the specific configurations, thresholds, or prompt structures that make our implementation perform. Patterns teach; parameters leak.
  2. Share the failure, not the fingerprint: Some of our most useful lessons came from things going wrong. We share those openly, because failure stories can build as much credibility as success stories. But we describe the failure mode generically, not the exact inputs, systems, or data that triggered it. 
  3. Keep customer data out of external content: That means no anonymized versions, no blurred versions, and no “just this once for the demo.” Examples in our external content are composite and synthetic by design. If an example could be mistaken for real customer data, we rebuild it to eliminate that risk. We treat this as a firm standard rather than a case-by-case call, which is what makes it practical to follow. 
  4. Don’t promise unreleased products: We write about what we’ve built and validated, not what we hope to ship. AI roadmaps can change quickly, and credibility is slow to build and quick to lose. 
  5. When in doubt, describe the discipline: If a detail feels borderline, we ask what the reader actually needs. More often than not, they need the reasoning—the tradeoff we weighed, the gate we added—not the artifact itself. The reasoning is almost always shareable. The artifact almost never needs to be.

Don’t get me wrong. This line is not always obvious, and we argue about it internally more than you’d think. We’ve found that useful, because it keeps sharing decisions deliberate rather than automatic.

Governance as an engineering function

Here’s something that surprises people: AI solutions we stand up internally, including the ones that never see a customer, go through a structured intake before they get access to systems or data. The intake asks blunt questions. What is the goal? Who is the business owner, and who is the technical owner? What systems and data does it touch, and does it read them or write to them? If it writes, which fields does it write to, and where do the values come from? Is it autonomous, or is a human in the loop? What guardrails protect sensitive data and prevent destructive actions? Is it customer-facing? 

None of these questions are exotic. Their power is that they are mandatory, answered in writing, and owned by named people. When an AI system can articulate its own blast radius before it exists, two things happen: The risky designs get caught while they’re still cheap to change, and—relevant to this post—the team has a clear, written record of which details of the system are sensitive. You can’t protect your secret sauce if you never wrote down what it is. 

Guardrails as product decisions

In our AI products, guardrails aren’t a paragraph in the terms of service. They are engineered constraints with the same status as functional requirements. Here are a few patterns we apply: AI output that touches consequential domains is designed to be advisory, with the customer’s own systems of record remaining the source of truth. Models are scoped to presentation and explanation in workflows where autonomous action could cause financial or operational harm, and customers set the parameters for how much autonomy any workflow has. Unknown situations default to escalation to a person rather than improvisation. And remediation suggested by AI is revalidated by automated checks before anyone acts on it. 

Just as important: The guardrails themselves are governed assets. They’re version-controlled, owned, auditable, and reviewed before release, exactly like code. We’ve found that a guardrail written down only in a slide deck is hard to rely on. One that lives in version control with a named owner can be reviewed and audited like any other control. 

Internal review is part of the pipeline

External content that describes our AI work goes through review by people whose job is to ask uncomfortable questions: Does this expose an internal system name that narrows an attacker’s search space? Does this metric reveal a customer’s scale? Would this example let a reader reverse-engineer a prompt? It’s the same muscle as code review, applied to communication, and it inherits from our broader information security policy rather than inventing new rules per team. 

The interesting side effect is that review makes our writing better, not blander. Being forced to strip out the specifics pushes you up a level of abstraction. And the abstraction is usually where the transferable insight lives anyway. 

What we’re still learning

We haven’t solved this. The line between “credible detail” and “leaked advantage” moves as the industry matures. Things that felt like differentiators two years ago are table stakes today, and safe to discuss. We’re still calibrating how fast to declassify our own past. We’re also learning that internal audiences read external posts too: Writing publicly about our principles has been a useful prompt for internal teams to check their own practices against them. 

And we’re still figuring out the right way to talk about results. Numbers build credibility, but numbers travel without their context. We’d rather underclaim and overdeliver, and we accept that this makes our posts less viral than they could be.

The journey continues

Everything above sounds like restraint, and it is. But in our experience, the restraint and the engineering are closely connected. A team that knows what its AI touches, guards it with versioned controls, and reviews what leaves the building is better prepared to protect customer data and to explain clearly how its AI works. That’s the standard we apply to our own platform work and AI products, and it’s the standard this series is written under. In future posts, we’ll go deeper into how we test, deliver, and operate AI—sharing everything except the sauce.

The short version

  • Writing publicly about AI engineering involves balancing credibility with protecting proprietary methods, customer data, and security. 
  • Describing an AI architecture as a pattern, rather than sharing its configurations or prompts, lets readers learn the approach without exposing how a specific system performs. 
  • Failure stories can be shared usefully when the failure mode is described in general terms instead of the exact inputs or data involved. 
  • Using composite, synthetic examples keeps real customer data out of blog posts, talks, and demos. 
  • A structured intake for AI projects records the goal, owners, data access, level of autonomy, and guardrails before a system is built. 
  • Guardrails can be managed like code: version-controlled, owned, and reviewed before release. 
  • Reviewing external content for sensitive details tends to shift writing toward the reasoning behind decisions, which is often the most transferable part. 

If you’re interested in more AI insights, watch these videos.