For developers maintaining internal tools: changing shared rules in reports and calculations, checking the results, and restoring previous behavior.Key takeawaysA compatible handler update can change the behavior of multiple programs on subsequent runs while leaving their source text unchanged.Checking expected outputs across the affected programs can reveal errors before a shared update is installed, but a bypassable check does not guarantee safe deployment.Recovery requires a saved working handler and a way to restore it even when its replacement is broken; restoring code does not undo external actions already performed.In the scheduling experiment, a smaller model used fewer tokens with a prepared language than with Python and feedback, but eight of 18 runs still failed validation and the stronger model showed no token advantage.Once a handler has been built and tested, people and AI models can compose programs from its supported operations and reuse the execution and validation code.We updated one shared handler in Extella and changed the formatting and validation rules of 40 report programs on their next run, without modifying their source code. When we deliberately introduced an error, a validation check detected incorrect totals in 35 of the reports and blocked the update. After we bypassed the check to test recovery, restoring the previous handler brought all 40 reports back to their correct totals.The approach puts shared logic in a handler: code that executes commands written in a small language for a particular task. Each program describes what needs to be done, while the handler takes care of execution. Libraries and services also let programs share logic; here we examine what this arrangement requires in practice.The experiment showed both sides of shared execution: one update can change multiple programs at once, but one error can affect many of them.For a developer maintaining these programs, the next question is how to test a shared change and restore the previous behavior if it goes wrong. We follow those steps below, then examine a separate experiment in which an AI model uses prepared commands to write new programs.Separating the program from its handlerChanging shared rules separately from a report requires separating two parts of the program. The report description holds data and commands. The handler holds the calculation, formatting, and validation code. A small language with commands for a particular set of tasks is called a domain-specific language, or DSL.The first handler needs to be written and tested against examples with known results. The developer also defines which commands it supports and what each one means. If those commands cover a new report’s requirements, its author can specify the data and commands using the calculation and validation code already in the handler.A familiar analogy is a template engine: a template specifies fields and placeholders, and the engine turns them into a finished page. Here, too, the report description is separate from the code that executes it. Changing the shared formatting code changes how reports look on subsequent runs (Scheme 1).It performs shared calculations, validation, and formatting. After an update, programs apply the new rules on subsequent runs without source changes, provided the handler remains compatible with the existing commands.How a shared handler changes program outputA short example shows exactly what stays in a program when its handler changes. In the ledger language, add N adds a number to the total and sub N subtracts one. A Python handler was tested with four saved programs. One looked like this:add 5add 7sub 2Starting at zero, the handler calculates 5 + 7 − 2 = 10. The first version returned the total; the second added the number of commands and the largest number specified. The total calculation stayed the same.After the handler was replaced, all four programs returned their previous totals with new response fields. Their source text was neither changed nor saved again.This is backward-compatible for an application that reads only the total field. A strict check of the field set could reject the new response. That would require preserving the old format or updating dependent programs.Why not use a regular interpreter or a library?At this point, a developer might ask why a custom language is needed when shared code can already live in a function, library, or service. A Python function is indeed enough for two arithmetic commands. Ledger shows how to separate a program from its execution; this example establishes no advantage over an ordinary function.In our comparisons, an ordinary script called programs through MCP (Model Context Protocol), an interface for connecting tools. MCP provided the call interface; no AI model chose the actions. A simple MCP server could also store and run programs. Windmill, a script-running environment, provided version history and rollback; it was tested on one machine.The next test therefore follows a shared change through a set of reports: applying it, detecting a defect, and restoring the previous results. That requires an expected total for each report.A shared change across reportsThe main experiment used 40 small report programs containing different sets of amounts. The shared handler was updated to format totals and reject duplicate row names. All 40 programs used the new rules on subsequent runs without source changes. The developer could maintain these rules in one place while each report kept its own data and commands. The next step was to check the results across all 40 reports.We then tested what would happen if the shared update were wrong. A deliberately faulty version dropped the fractional part of each row's amount before adding the amounts together. Before installing it, a separate validation program compared the results with values calculated in advance. It found 35 incorrect totals out of 40 and rejected the update. The previous handler remained in place and continued to produce 40 correct totals.Directly registering the handler could bypass this check. The experiment did exactly that: it installed the faulty version, obtained incorrect totals, then restored the previous version and recovered all 40 correct results.The check worked because correct totals were already known for all 40 programs. Recovery used a saved copy of the previous handler, registered again after the faulty update.The 40-report experiment tested updating and recovery; it did not compare maintenance costs with a library or service. A separate test changed the appearance of one report and showed no time or token savings. Each approach was tried once.What running on several devices requiresChecking totals is not enough when reports run on different devices. The new handler also has to run in each environment. Each device needs a runner, the appropriate handler version, and the dependencies it uses. Before updating, check the environment and run validation programs on each device. Saving the new source code alone does not establish that these requirements are met.A separate experiment examines dependencies and code delivery on two devices. It updated a saved calculation operation while leaving the language handlers unchanged. It helps explain deployment requirements, but does not test replacing a shared handler.What changes when AI writes the program?So far, we have examined changes to programs that already work. The prepared handler can also serve the next program: a person or an AI model describes the task using its commands. The model can draw on operations whose execution and checks have already been implemented. To find out whether such commands help a model, we ran a separate employee-scheduling experiment comparing schedule correctness and token use.The model wrote either a Python program that produced a schedule or commands in a scheduling language. Prewritten code checked hours and constraints, such as whether enough employees were available at a given time. Both formats used the same rules; in the DSL version, the checks were part of the handler and made no AI calls.Three approaches were compared on six tasks using qwen-flash. Each task was repeated three times for each approach, giving 18 task runs per approach. In the approaches with feedback, a run allowed up to three attempts: after an error, the model received feedback and could revise its program.ApproachTask runs that passed validationTokens across 18 task runs, including revisionsPython, one attempt2 of 1847,104Python, up to three attempts with feedback6 of 18154,223Scheduling DSL, up to three attempts with feedback10 of 1826,892In the last two approaches, the model received the same general rules and up to three attempts. Python with revisions used about 5.7 times as many tokens as the scheduling DSL. These totals include both successful and unsuccessful task runs. Eight DSL runs still failed validation. In two cases, Python with revisions passed while the scheduling DSL failed.With the stronger qwen3.7-max-2026-06-08 model, each task was run once per approach. All three approaches passed all six tasks, and the scheduling DSL had no token advantage. These results come from saved logs. The logs do not include the models' final programs, so they cannot be used to independently rerun every generated schedule.These results concern a model using commands that are already available. The token totals exclude developing and testing the handler. They compare the scheduling approach as a whole, including the language, execution, and feedback. They do not measure the cost of updating reports. A stronger model could help write a handler for a smaller model to use, but the experiment did not measure the full cost of that workflow.What this separation requiresThe report experiment checked totals, while the scheduling experiment checked constraints. A working system also needs compatibility with applications that consume the programs' output. A breaking change to that output requires preserving the previous format or updating dependent applications.Recovery needs a saved working handler and a way to restore it even if the new version is broken. Restoring the code does not undo completed actions, such as an email already sent. Built-in version history and updates during running calls were not tested.The checking code can also be wrong. The first schedule validator missed a five-minute gap; this article uses the corrected experiment. The checks therefore need tests with valid and invalid inputs. Changes to the checking code, including changes made by an agent, need review separately from changes to the program being checked.The execution path can add latency. A separate comparison made 30 repeated calls per method. The medians were about 9.4 seconds through the program-execution service and 0.025 seconds through a simple local runner. Computation ran on the same laptop, but the call paths differed; this does not isolate the cost of the language itself.Checks in the handler help find errors in a program, but do not restrict the handler’s own permissions. In the configuration described here, the handler runs with the user’s permissions, so access to files, the network, and system commands needs separate restrictions.When this separation makes senseA handler is worth considering when several tasks use a stable set of operations. Reports may contain different data while calculating and displaying totals according to shared rules. A new report can then use existing commands. When a shared rule changes, the developer updates the handler and checks every affected report.The initial preparation falls to whoever first defines the commands, writes the handler, and tests it. Other people and AI models can then compose programs from those operations, reusing the code that executes and checks them. The developer still needs to check that each program meets its requirements. A task outside the supported operations requires extending the handler and testing it again.A library or service also supports shared code. The choice depends on how well a separate language expresses your tasks and whether reuse justifies maintaining it. Compare the full cycle: building the handler, adding programs, changing shared rules, checking results, and recovering from errors. For one report, this extra work may be unnecessary.We ran these experiments, calling this mechanism CSPL (Container Specific Programming Language): each saved program specifies its language, and a handler registered on the device executes its commands. The code, Erun logs, and results of the 40-report and scheduling experiments are available on GitHub.To assess the approach for your own tools, choose a small set of programs that share rules. Establish their expected results, change one rule, and check whether you can both apply and reverse the change. Account for writing the handler and maintaining those checks before deciding whether a custom language is worth keeping.