Introduction
In Roman mythology, Janus was the god of gates, doorways, thresholds, beginnings, and transitions. January is known as after him. He’s normally represented with two faces. One face seems to be backward: to the realized path, earlier initiatives, repeated errors, reusable patterns, architectural conventions, and the teachings realized from codebases that turned onerous to keep up. The opposite face seems to be ahead: to future frameworks, new channels, altering mannequin suppliers, completely different storage layers, and capabilities that don’t exist but.
This double imaginative and prescient is more and more essential when constructing software program with AI coding assistants. With fashionable coding brokers, it’s now doable to create a working prototype in just a few hours. Code is cheaper to generate, simpler to change, and quicker to assemble. However this velocity additionally creates a brand new drawback: when code is produced shortly with no clear construction, the venture can change into obscure, keep, and prolong.
For information scientists, this shift is especially attention-grabbing. Functions that beforehand required substantial software program engineering assist can now be prototyped utilizing pure language and AI coding brokers. Transferring from notebooks and experiments to APIs, interfaces, and deployed functions has change into extra accessible. But producing a working utility and engineering a system that may evolve are two very completely different challenges.
I explored this drawback in additional element in a earlier article on hidden technical debt in AI growth [1], the place the principle argument was that velocity with out requirements can create fragile AI merchandise. This text continues from that concept, however focuses on a extra sensible query: what sort of beginning construction will help us construct AI functions which might be simpler to evolve?
The chance is just not solely that the code is messy immediately. The deeper danger is that the venture has no reminiscence of previous architectural classes and no room for future change. A coding agent can add a operate, create a file, wire an endpoint, or combine a framework in a short time. However with no clear construction, it could place logic wherever it’s best within the second: inside an endpoint, inside a framework-specific object, inside a helper operate, or inside a file that was by no means meant to personal that accountability.
Because of this AI/ML initiatives want Janus-like imaginative and prescient. Trying backward, we should always seize the teachings that groups typically be taught the onerous manner: separate tasks, keep away from duplicated setup, hold contracts clear, check the core logic, and stop exterior instruments from leaking into each a part of the applying. Trying ahead, we’d like sufficient flexibility to accommodate new necessities, applied sciences, and capabilities with out redesigning all the system.
The aim is just not structure for its personal sake. The aim is to make quick growth safer and extra repeatable. A baseline defines the minimal architectural selections that shouldn’t be reinvented in each venture: tool-agnostic code, replaceable infrastructure, testable core logic, decrease coupling to frameworks, and clear separation of considerations. When that baseline is packaged as a reusable template, it turns into a scaffold: a sensible beginning construction with configuration, backend providers, frontend wiring, Docker, checks, documentation, schemas, adapters, and growth guidelines already in place. This issues as a result of many AI and information science functions want comparable foundations. If each venture recreates them from scratch, groups lose time and accumulate inconsistencies. A scaffolded baseline permits groups to maneuver quicker with out turning each new utility right into a one-off construction.
If AI brokers can write the code, what can we nonetheless want to know to engineer software program that lasts?
1. Baselines: Giving AI Tasks a Beginning Structure
A baseline offers a venture a transparent model one. It defines what we all know, what we settle for as the present place to begin, and which ideas future iterations are anticipated to protect. With out this reference, groups can hold altering an utility with out having the ability to inform whether or not they’re enhancing it or just making it completely different.
This turns into particularly essential in AI-assisted growth. If there isn’t a agreed structure, no outlined boundaries, and no established patterns, each iteration can reshape the system in a distinct course. Even when groups use Cursor/Claude/Codex guidelines, ability recordsdata, or coding tips, these directions will not be an alternative choice to an architectural baseline.
These mechanisms stay helpful as a result of they assist coding brokers perceive native conventions and generate code extra constantly. Nevertheless, they work higher when there may be already a construction to observe. The baseline supplies each the agent and the developer with a secure reference: the place tasks belong, which boundaries shouldn’t be crossed, and what patterns ought to be reused.
For information scientists, the baseline will depend upon the kind of utility being developed. An agentic workflow may have specific boundaries for instruments, state administration, permissions, and auditing. A document-processing system could separate classification, extraction, validation, and human evaluate. A predictive service could isolate function processing, mannequin inference, monitoring, and fallback mechanisms.
The target is to not impose the identical structure on each venture, however to protect reusable engineering ideas whereas protecting functions impartial of particular applied sciences.
2. Structure Selections: What Knowledge Scientists Ought to Know
There are lots of methods to arrange a software program system, and every architectural selection addresses a distinct concern. The issue begins when an utility grows with out clear boundaries, tasks, or dependency guidelines.
That is significantly widespread when shifting from notebooks and experimental scripts to manufacturing functions. Mannequin inference, preprocessing, validation, API logic, database entry, enterprise guidelines, and exterior integrations can shortly change into intertwined. The appliance may go, however changing a mannequin, altering a database, or testing particular person elements turns into more and more troublesome.
Software program engineering gives well-established ideas to handle these challenges [2]:
-
Separation of Considerations and SOLID ideas: Assist arrange tasks, scale back coupling, and hold elements targeted, extensible, and interchangeable.
-
Clear Structure and Hexagonal Structure: Present approaches for shielding utility logic from exterior dependencies, similar to databases, frameworks, mannequin suppliers, and third-party providers [3].
-
Ports, adapters, and dependency injection: Translate architectural boundaries into sensible mechanisms, permitting implementations to get replaced with out altering the underlying enterprise logic.
Contemplate a predictive utility that depends on a specific mannequin supplier, database, and API framework. If these dependencies are embedded immediately into the prediction logic, altering any of them could require modifications all through the applying. By introducing clear interfaces and adapters, the core habits can stay secure whereas exterior elements evolve independently.
The identical precept applies to agentic workflows. An agent shouldn’t must know the implementation particulars of each instrument, storage mechanism, or exterior service it makes use of. Clear contracts and dependency boundaries make these elements simpler to exchange, check, and keep.
A number of implementations illustrate these architectural ideas in follow. One significantly helpful instance comes from AWS Prescriptive Steerage [10], which supplies a Python utility constructed round Hexagonal Structure. The reference venture separates area logic, ports, adapters, API entry factors, checks, and infrastructure. We use this instance as a result of AWS supplies each the implementation and detailed steering, making it simpler to know how architectural selections translate into executable code.
As illustrated in Determine 1, completely different architectural approaches can complement one another. A sensible AI baseline could mix vertical slicing to arrange associated capabilities, Clear Structure to guard core utility logic, Hexagonal Structure to attach that logic by way of ports and adapters, and dependency injection to maintain implementations interchangeable.
The target is to not observe a specific structure mechanically, however to know which tasks ought to stay secure and which elements ought to be free to vary.
3. Design Patterns as Lego Bricks: Turning Boundaries into Code
Software program structure defines the general form of a system: its accountability boundaries, dependency guidelines, and the separation between secure utility logic and altering applied sciences. However architectural selections should finally be translated into code. That is the place design patterns change into helpful.
Consider design patterns as LEGO bricks: reusable constructing blocks that assist implement architectural selections with out reinventing options for recurring issues.
For instance, if we need to change an LLM supplier with out rewriting the applying, an Adapter can isolate the provider-specific implementation. If we need to check enterprise logic with out connecting to an precise database, a Repository interface mixed with Dependency Injection can separate persistence from utility habits. If we’d like completely different model-selection methods, a Technique sample could make these options interchangeable.
Different patterns, similar to Manufacturing facility and Registry, will help create, configure, and uncover elements with out hardcoding each implementation into the applying. Determine 2 summarizes a number of recurring mechanisms that assist translate architectural ideas into concrete implementations.
These patterns will not be unique to AI growth. They’re established software program engineering practices that change into significantly beneficial when constructing functions with coding brokers. As an alternative of repeatedly asking an agent to invent a brand new integration or element construction, we are able to present acquainted patterns and conventions that information its implementation.
The target is to not introduce as many patterns as doable. Extreme abstraction could make a easy utility unnecessarily advanced. The worth comes from recognizing recurring issues and making use of the smallest set of patterns that helps protect clear boundaries, testability, and suppleness.
Structure defines the boundaries. Design patterns present the constructing blocks to implement them.
4. From Architectural Baselines to Scaffolds and Harnesses
Understanding architectural ideas is helpful, however making use of them constantly throughout initiatives is a distinct problem. Knowledge scientists typically develop functions with comparable foundations: API endpoints, mannequin inference providers, configuration administration, logging, checks, exterior integrations, and deployment infrastructure. Recreating these elements for each new venture is time-consuming and may introduce pointless inconsistencies.
That is the place scaffolding turns into beneficial.
An architectural baseline defines the ideas, boundaries, and conventions a venture ought to observe. A scaffold turns these selections right into a reusable beginning construction, with predefined modules, interfaces, configuration, checks, and extension factors. As an alternative of ranging from an empty repository or asking a coding agent to invent all the utility construction, builders start with a basis that already incorporates established engineering practices.
Instruments similar to Cookiecutter[4], Copier[5], and Plop[6] can automate this course of. Template engines generate preliminary venture constructions from predefined configurations, whereas specialised turbines can add recurring elements, similar to API endpoints, adapters, repositories, or checks, as an utility grows.
Nevertheless, a scaffold is just not essentially restricted to producing an utility as soon as. Round it, a era harness can coordinate how initiatives are configured, instantiated, prolonged, and validated. This may occasionally embody configuration schemas, turbines, pre- and post-generation hooks, dependency setup, formatting, and automatic checks.
For instance, a pre-generation hook can validate venture names and configuration choices, whereas a post-generation hook can register elements, initialize dependencies, format code, or execute checks. Instruments similar to OpenAPI Generator can complement the scaffold by producing API interfaces and consumer code from established contracts.
AI coding brokers introduce one other layer of flexibility. They’ll generate domain-specific implementations that can’t be absolutely described by way of mounted templates, similar to a brand new fraud detection workflow, a doc extraction element, or a mannequin inference service.
Latest analysis on harness engineering supplies an attention-grabbing perspective on this rising follow. Galster et al. [9] examined configuration mechanisms for agentic coding instruments throughout 2,853 GitHub repositories, figuring out approaches similar to context recordsdata, expertise, and subagents. Their findings spotlight how builders are starting to formalize the directions and reusable capabilities obtainable to coding brokers.
The essential distinction is that deterministic turbines present predictable constructions, whereas coding brokers present flexibility inside these constructions. Generated modifications can then be evaluated utilizing architectural dependency checks, schema validation, linting, kind checking, safety scanning, and automatic checks.
Past code era, coding agent harnesses can present reusable directions, expertise, plugins, and exterior instruments that assist brokers perceive and modify present functions. For instance, instruments similar to CodeGraph [8] can expose codebase construction, dependencies, and alter affect by way of MCP, giving brokers structured context earlier than making modifications. These capabilities complement scaffolding by supporting growth past the preliminary venture setup. The structure and governance of coding agent harnesses deserve a deeper dialogue, which I’ll discover in a separate article.
Whereas era harnesses standardize how functions are created and prolonged, coding agent harnesses arrange the context, capabilities, and controls obtainable to brokers throughout growth. Collectively, they join reusable architectural foundations with AI-assisted implementation.
This strategy doesn’t eradicate engineering selections or assure that each generated element will likely be right. As an alternative, it reduces repetitive setup and creates a extra constant surroundings during which builders and coding brokers can construct, check, and evolve AI functions.
As illustrated in Determine 3, these mechanisms can work collectively all through the event lifecycle, from defining architectural foundations and producing venture constructions to AI-assisted implementation, validation, and steady enchancment.
Conclusion: Engineering Issues Extra
AI coding brokers are altering how software program is constructed. Duties that when required hours of implementation can now be delegated to methods able to producing code, modifying repositories, operating checks, and proposing full options.
However making code simpler to supply doesn’t make software program simpler to engineer.
Somebody nonetheless must determine how tasks ought to be separated, which dependencies are acceptable, what ought to stay replaceable, and the way the system can evolve with out breaking present habits. For information scientists shifting past experimentation into utility growth, understanding these selections turns into more and more essential.
That is the place architectural baselines, reusable scaffolds, and harnesses come collectively. The baseline captures engineering selections and classes realized. The scaffold interprets them right into a sensible beginning construction. Technology harnesses automate and validate recurring growth duties, whereas coding agent harnesses present the directions, capabilities, instruments, and controls that information AI-assisted implementation.
Nevertheless, these mechanisms shouldn’t change architectural reasoning. They need to make it extra specific, reusable, and simpler to confirm. In any other case, we danger automating not solely code era but additionally the buildup of architectural errors.
Returning to Janus, good engineering requires wanting backward to protect what now we have realized and ahead to anticipate what could change. The aim is to not generate extra code, and even to generate it quicker, however to construct functions that stay comprehensible, maintainable, and adaptable as necessities, applied sciences, and groups evolve.
The better it turns into to put in writing code, the extra essential it turns into to engineer what we construct.
References
[1] Gomes-Gonçalves, E. (2026, January 27). Do you odor that? Hidden technical debt in AI growth: Why velocity with out requirements creates fragile AI merchandise. In direction of Knowledge Science. https://towardsdatascience.com/do-you-smell-that-hidden-technical-debt-in-ai-development/
[2] Richards, M. (2015). Software program structure patterns. O’Reilly Media. https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/
[3] Amazon Internet Companies. (n.d.). Hexagonal structure sample. AWS Prescriptive Steerage. https://docs.aws.amazon.com/prescriptive-guidance/newest/cloud-design-patterns/hexagonal-architecture.html
[4] Cookiecutter. (n.d.). Cookiecutter: Higher venture templates. https://cookiecutter.readthedocs.io/
[5] Copier. (n.d.). Copier documentation. https://copier.readthedocs.io/en/secure/
[6] Plop. (n.d.). Plop documentation. https://plopjs.com/documentation/
[7] DrivenData. (n.d.). Cookiecutter Knowledge Science. https://cookiecutter-data-science.drivendata.org/
[8] CodeGraph. (n.d.). CodeGraph: Cross-language code intelligence for AI brokers and builders. GitHub. https://github.com/codegraph-ai/CodeGraph
[9] Galster, M., Mohsenimofidi, S., Lulla, J. L., Abubakar, M. A., Treude, C., & Baltes, S. (2026). Harness engineering for agentic AI coding instruments: An exploratory research. arXiv. https://arxiv.org/abs/2602.14690
[10] Oruc, F., Goby, D., Kunce, D., & Ploski, M. (n.d.). Construction a Python venture in hexagonal structure utilizing AWS Lambda. AWS Prescriptive Steerage. https://docs.aws.amazon.com/prescriptive-guidance/newest/patterns/structure-a-python-project-in-hexagonal-architecture-using-aws-lambda.html
