By St\u00e9phane Cagnon \u00b7 October 8, 2026<\/p>\n<\/div><\/div><\/div><\/div><\/div>
\u201cWe just need to extend the customer number.\u201d Who would commit to a deadline based on that one sentence?<\/b><\/p>\n
That’s often how a change on IBM i begins: a short request from the business, landing on the CIO’s desk with a deadline already in mind.<\/p>\n
In this article, I focus on the exact moment when you have to commit. Three familiar requests run through it: changing a VAT rate, extending a customer number, and opening a function to the web. Each time, the requirement is the same: explain the scope, show what justifies it, and bring together the people who own the decision.<\/p>\n<\/div><\/div><\/div>
Key takeaways<\/span><\/p>\n<\/div> A \u201csimple\u201d request is only simple in how it’s worded<\/b>: without visibility into dependencies, estimates shift because the scope becomes clear too late.<\/p>\n<\/div><\/li> DISCOVER works like a map<\/b>: the business, the IBM i expert, and the CIO all read the same view, each at their own zoom level.<\/p>\n<\/div><\/li> A computed map, not a guessed one<\/b>: the repository is deterministic.<\/p>\n<\/div><\/li><\/ul><\/div><\/div> The word \u201cjust\u201d describes the request. It says nothing about its consequences. A single field can run through orders, invoices, and exchanges with other applications.<\/p>\n Take a concrete example. Finance wants to raise a VAT rate from 10% to 12%. You find the rate table, and the change looks trivial. Then a question comes up: if last month’s invoice is reprinted, does it keep its original amount? What about the matching credit note? It all depends on the business rules actually being executed: what the application stores, what it recalculates, and when.<\/p>\n On IBM i, applications carry years, often decades, of business decisions. That wealth is a major asset, but a hard one to tap into:<\/p>\n<\/div> only a handful of key people can explain it;<\/p>\n<\/div><\/li> documentation is scattered, incomplete, or out of date;<\/p>\n<\/div><\/li> time slips away rebuilding context before anyone can act.<\/p>\n<\/div><\/li><\/ul> The result: one dependency surfaces, then another, and the estimate drifts. So ask yourself: when would you rather discover a dependency before the quote, or after you’ve committed?<\/b><\/p>\n This is exactly the need DISCOVER<\/a> addresses: making what’s affected visible before the commitment is locked in. For the CIO, the value is immediate: concrete evidence to justify budget and timelines, and fewer blind spots.<\/p>\n<\/div> DISCOVER works like a geographic map of your application portfolio.<\/b> Anyone can look at a map, get their bearings, and find what concerns them. You view it at country scale to grasp the big picture, then zoom in on a region, a city, a street. The map stays the same; only the level of detail changes.<\/p>\n Applied to an IBM i application, this metaphor changes the nature of scoping meetings:<\/p>\n<\/div> the business<\/b> states the need and the expected outcome;<\/p>\n<\/div><\/li> the IBM i expert<\/b> shows the dependencies and checks the relationships;<\/p>\n<\/div><\/li> the CIO<\/b> makes the call, based on a shared view.<\/p>\n<\/div><\/li><\/ul> Everyone looks at the same map. You follow a lead, step back, and adjust the view to the question at hand. Decision-makers take part without reading a single line of RPG<\/b>, while experts keep all the technical depth they need.<\/p>\n Moving between levels is seamless. At the top, the functional map shows the main domains (customer management, item management, settings\u2026) and, in red, how they interact. At the intermediate level, component diagrams and the data model reveal files, programs, and links. At the finest level, the code diagram exposes a program’s logic. A local question always fits back into the wider portfolio, with a clear path back to the technical details.<\/p>\n Even when a repository already exists, this experience makes the difference. Information takes on new value when a team can explore it, challenge it, and agree on what it shows.<\/p>\n<\/div> Filter the procedure repository on VAT: DISCOVER surfaces the procedure that retrieves the rate, linked to its module, its service program, and every program that calls it. The technical name hardly matters. What counts is the relationship it reveals: several processes rely on the same point<\/b>, and the CIO finally sees why the analysis reaches beyond the original component.<\/p>\n Data lineage completes the picture. Starting from the order detail file, a screen field, or a report, you can see where each value comes from and where it goes, calculation by calculation, all the way back to the original business rule<\/a>. For the finance department, the stakes are clear: knowing which calculations and uses to review before changing the rule.<\/p>\n<\/div> This time, the request is blocking: 99,999 customers, the 5-digit limit has been reached, and the sales team can no longer create new customers. DISCOVER starts from the CUSTOMER file and its identifier, follows the relationships to history and orders, then on to the linked components. The scope takes shape.<\/p>\n Not everything that’s linked will necessarily change. Impacted components are grouped into families (data, access, processing, interfaces, SQL), and the team qualifies each impact: modify, check, or test. That’s the foundation for a well-argued estimate<\/b> and a clear division of work.<\/p>\n<\/div> A 5250 screen is often the entry point to a process that validates data, assigns an identifier, and feeds other processes. Where is the duplicate check? Which process approves the creation? DISCOVER pinpoints that logic. You can then decide what to reuse (for example by exposing it as a web service) before building the modern interface.<\/p>\n<\/div> Visual, non-linear navigation<\/b>: zoom, focus on a component, 3D view, call chain all the way to the screen.<\/p>\n<\/div><\/li> Code diagrams and graphical version comparison<\/b>, for experts.<\/p>\n<\/div><\/li> Natural language assistant<\/b>: query your application<\/a> (for example, \u201cfind all paths leading to the CUSTOMER component\u201d) and the question becomes a diagram you can explore.<\/p>\n<\/div><\/li> AI-generated business rule documentation<\/b>, for the team to review and validate.<\/p>\n<\/div><\/li> Named, saved diagrams<\/b>, reusable in project documentation exported to Confluence or Markdown.<\/p>\n<\/div><\/li><\/ul> A map is only valuable if it’s accurate. To base decisions on it, you need to know what it’s built on. This is where DISCOVER stands apart: its relationships are computed, not guessed<\/b>.<\/p>\n The repository is built by analyzing IBM i sources and objects. Every relationship displayed comes from that analysis, never from assumption. This delivers four guarantees:<\/p>\n<\/div> Known provenance<\/b>: you know which sources and objects the information comes from.<\/p>\n<\/div><\/li> Computed relationships<\/b>: fields, procedures, and dependencies are established through analysis.<\/p>\n<\/div><\/li> Reproducible analysis<\/b>: same inputs, same parameters, same relationships.<\/p>\n<\/div><\/li> Verifiable freshness<\/b>: the scope covered and the refresh schedule are known; the repository isn’t a frozen snapshot but a reflection of production.<\/p>\n<\/div><\/li><\/ul> In practice, the same question always gets the same answer<\/b>. No language model reinterprets the map each time it’s consulted. That’s essential when you commit a budget, justify a timeline to management, or split up checks across a team: everyone needs to find tomorrow what they saw today.<\/p>\n AI certainly has its place in DISCOVER, but in a clearly defined role. When the assistant receives a natural language question, it translates it; it doesn’t make up the answer. The paths it displays come straight from the computed repository. Likewise, the functional map<\/a> combines a deterministic algorithm (the Louvain method, which detects groups of tightly connected elements) with AI to name those groups. As for generated documentation, it’s a solid starting point that human review turns into a trusted reference.<\/p>\n<\/div> AI models are advancing fast, and large language models have been released at a sharply accelerating pace in 2026. These capabilities should be put to work: LLMs help analyze, propose, and deliver faster.<\/p>\n But this acceleration shifts the bottleneck. If a change can be proposed in minutes, the real question becomes: how does the team understand its consequences for the application?<\/b> The CIO, the business, and the experts must still be able to examine the scope, follow a dependency, and discuss what needs to be preserved. The more changes you produce, the more you need to understand and validate them together.<\/p>\n That’s why the faster AI moves, the more indispensable specialized studios like DISCOVER will become<\/b>. A general-purpose conversational assistant answers one question at a time, in a linear way. A specialized studio offers what a conversation can’t:<\/p>\n<\/div> Shared understanding<\/b>: DISCOVER provides a common, clear, non-linear view; you switch levels and follow your line of reasoning without turning every move into a new question.<\/p>\n<\/div><\/li> Better-informed decisions<\/b>: a computed, deterministic repository lets you assess impacts with confidence.<\/p>\n<\/div><\/li><\/ul> My conviction comes down to one sentence: the faster we can act, the more it pays to make our understanding of the system explicit and shareable. Let’s harness the power of AI and give the team the map it needs to stay in control of the effects.<\/p>\n<\/div> How many of your projects start with: \u201cWho knows this part of the application?\u201d In four common situations, understanding the application portfolio determines when work can actually begin.<\/p>\nBudget depends on scope<\/h2><\/div>
One shared map to decide together<\/h2><\/div>
Three requests, one approach<\/h2><\/div>
Changing a VAT rate: follow the rule and the data<\/h3><\/div>
Extending the customer number: scope and estimate<\/h3><\/div>
Opening a function to the web: recover the rules before transforming<\/h3><\/div>
Other key capabilities<\/h3><\/div>
Determinism: a map you can rely on<\/h2><\/div>
The faster AI moves, the more control matters<\/h2><\/div>
Less context to rebuild, more time to act<\/h2><\/div>
![\"stephane](\"https:\/\/www.arcadsoftware.com\/discover\/wp-content\/uploads\/2026\/08\/Portrait-Stephane-Cagnon-1.png\" "\\"Portrait")
<\/span><\/div><\/div><\/div>