From Deterministic Code to Flexible Systems: How Software is Eating Messy Problems

The Limits of Traditional Software

For decades, the implicit contract in software was this: if you can define every rule, every edge case, and every exception in advance, you can automate it. If not, you're out of luck—or stuck hiring consultants to wrangle spreadsheets and clean up after the fact.

But much of the highest-value work in business—especially in domains like ERP migrations, billing transformations, and financial reconciliation—lives outside that clean, deterministic boundary. The data is inconsistent. The rules vary by customer, system, or region. The inputs aren't APIs—they're PDFs, exports, or half-complete specs.

Determinism Still Wins—But the Path Changes

At Doyen, we're working on this problem. Our core approach is to still produce deterministic, testable software, but to automate as much of the process of getting there as possible. That means generating structured code from partial artifacts: documentation, examples, feedback, and historical mappings.

Automation as Draft, Not Decision

We use large language models to assist in drafting transformations, identifying schema patterns, and proposing logic—but we treat those outputs as starting points. Everything eventually becomes real code that runs deterministically. We also generate tests alongside the logic to ensure correctness, and we surface everything for human review and validation.

This isn't "let the LLM do the work." It's: let automation do the repetitive drafting, then hand it back to a human to guide and approve.

Systems That Improve Over Time

Over time, feedback tightens the loop. More suggestions become accurate. Review cycles shrink. The system improves. The end result is a flexible system that tolerates variability, adapts across cases, and stays grounded in testable logic.

Where We're Headed

There's still a long way to go. But we're making steady progress on bringing structure, automation, and clarity to areas of work that were previously handled manually or not at all. The challenges ahead—handling ambiguity, mapping across inconsistent systems, surfacing edge cases before they become failures—are real and technical. We're building systems to take them on, one layer at a time, with correctness, auditability, and trust at the center.

If you're an engineer excited about tackling these challenges at the intersection of AI and enterprise software, we'd love to hear from you at careers@doyen.com.