Mechanical Orchard

AI agents promise to make code translation fast. But starting with code translation is precisely why so many modernization attempts fail. The trickiest and riskiest phase is toward the end, when it’s time to verify if it all works. Can you use AI for that? On July 16, join us in Dallas to get candid about how to close that gap — automating verification safely and accurately through proving equivalence against real production data. Over dinner at #Nobu, you'll hear from distinguished technology analyst Arun Batchu, Thomas Squeo from Thoughtworks, and our own Nicholas Keune about where common approaches break down, and how a behavior-based approach can deliver modern code that’s verified, production-ready, AND blazingly fast. Reserve your spot: https://hubs.la/Q04kxmqx0

“There's a joke that AI turns a 10x engineer into a 100x engineer and a 0.1x engineer into a 0.01x engineer — it multiplies whatever judgment you bring, including none.” Only funny ‘cause it's true: as tooling improves, the bottleneck increases around the judgment you bring to the table. Jai Morjaria shares what six weeks of building with AI agents taught him: https://lnkd.in/dZZtKQX6

Given the exponentially increasing speed of what AI can do, problems once considered too risky or expensive to touch are suddenly within reach. But the challenge is to surface the harder parts. We spent two days at a farm in Tennessee with a group of notable, curious minds, asking what AI changes about the economics of building software. Read our reflections from the Orchard Retreat here: https://hubs.la/Q04kQCnJ0

Applying AI’s evolving competencies to modernization is exciting, but it isn’t the silver bullet that everyone’s hoping it will be. The reason why modernization stalls or fails isn’t from the code translation phase, which is where most vendors are applying AI. It’s from the phase following it: the arduous, uncertain periods of debugging and testing toward the very end. Join us and our partner Thoughtworks in this webinar to discuss how a test-driven, behavioral method offers a better solution than conventional approaches. In 45 minutes, you'll learn: - Why leading with code transpilation and business rules extraction falls short - How a test-driven, behavioral approach bridges the gap between understanding and proof - Why validating against real data at every step is the key to resolving the risk-vs-speed tradeoff Register to join the live conversation with Michael Ljung, Google’s David Y., and our own Nicholas Keune: https://hubs.la/Q04kxmB50

AI agents promise to make code translation fast. But where projects stall (or fail) is toward the end: when it’s time to verify that it all works. On July 16, join us in Dallas to get candid about how to close that gap — automating verification safely and accurately through proving equivalence against real production data. Over dinner at Nobu Restaurants, you'll hear from distinguished technology analyst Arun Batchu, Thomas Squeo from Thoughtworks, and our own Nicholas Keune about where common approaches break down, and how a behavior-based approach can deliver modern code that’s verified, production-ready, AND blazingly fast. Reserve your spot: https://hubs.la/Q04kxmpv0

One of the most enticing pitches currently in mainframe modernization — extract the business rules, rebuild from that list — skips the verification part. The part that determines whether the code actually works. Sam Sanders explains why mainframe modernization is a verification problem: https://hubs.ly/Q04kQyH00

Most modernization efforts fall apart toward the end, after code translation: the arduous, uncertain periods of debugging and integration testing. We’re hosting a webinar with our partner, Thoughtworks, to discuss how a test-driven, behavioral method solves for validating equivalence as the system is being rewritten. In 45 minutes, you'll learn: - Why leading with code transpilation and business rules extraction falls short - How a test-driven, behavioral approach bridges the gap between understanding and proof - Why validating against real data at every step is the key to resolving the risk-vs-speed tradeoff Register to join the live conversation with Michael Ljung, Google’s David Y., and our own Nicholas Keune: https://hubs.la/Q04kxmzy0

AI agents promise to make code translation fast. But they don’t necessarily help with verification: the slowest, riskiest parts of modernization that come at the end. That's where projects stall, and why there’s a 70% failure rate. On July 16, join us in Dallas to get candid about how to close that gap — automating verification safely and accurately through proving equivalence against real production data. Over dinner at Nobu, you'll hear from distinguished technology analyst Arun Batchu, Thomas Squeo from Thoughtworks, and our own Nicholas Keune about where common approaches break down, and how a behavior-based approach can deliver modern code that’s verified, production-ready, AND blazingly fast. Reserve your spot: https://hubs.la/Q04jNKlx0

Most mainframe modernization projects treat decades of business logic as a code translation problem. Translating COBOL syntax into Java without first mapping what the system does in production doesn't reduce legacy debt, it merely relocates that debt to the cloud. Imogen takes a different approach: capture actual production data flows, build a verified test harness, then generate and validate replacement workloads continuously rather than in one high-stakes cutover. Stephanie Walter from HyperFRAME Research explains why this matters: https://lnkd.in/deJYvws7

When it comes to modernization, the failure rates aren’t due to lack of speed. Rather, failure usually comes from the phase following code translation: arduous, uncertain periods of debugging and testing that bleed time *and* money. Join us for a webinar with our partner, Thoughtworks, on how a test-driven, behavioral method offers a better solution than conventional approaches. In 45 minutes, we’ll cover: - Why leading with code transpilation and business rules extraction falls short - How a test-driven, behavioral approach bridges the gap between understanding and proof - Why validating against real data at every step is the key to resolving the risk-vs-speed tradeoff Register to join the live conversation with Thoughtworks' Michael Ljung, Google’s David Y., and our own Edward Hieatt: https://hubs.ly/Q04jYbh40