Analysis, Assessment, Rebuild

Bahmni and Legacy Code Migration

Bahmni is an open-source Hospital Administration
System & EMR constructed to assist healthcare supply in low-resource
settings offering a wealthy interface for scientific and administrative customers.
The Bahmni frontend was initially
developed utilizing AngularJS (model 1.x)—an
early however highly effective framework for constructing dynamic net purposes.
Nevertheless, AngularJS has lengthy been deprecated by the Angular crew at Google,
with official long-term assist having resulted in December 2021.

Regardless of this, Bahmni continues to rely closely on AngularJS for a lot of of
its core workflows. This reliance introduces vital dangers, together with
safety vulnerabilities from unpatched dependencies, problem in
onboarding builders unfamiliar with the outdated framework, restricted
compatibility with trendy instruments and libraries, and lowered maintainability
as new necessities are constructed on an getting older codebase.

In healthcare programs, the continued use of outdated software program can
adversely have an effect on scientific workflows and compromise affected person knowledge security.
For Bahmni, frontend migration has change into a important precedence.

Analysis, Assessment, Rebuild

Determine 1: Analysis, Assessment, Rebuild Workflow

The workflow I adopted known as “Analysis, Assessment, Rebuild” — the place
we do a characteristic migration analysis utilizing a few MCP servers, validate
and approve the method AI proposes, rebuild the characteristic after which as soon as
all of the code technology is completed, refactor issues that you just did not like.

The Workflow

1. Put together a listing of options focused for migration. Choose one characteristic to
   start with.
2. Use Mannequin Context Protocol (MCP) servers to analysis the chosen characteristic
   by producing a contextual evaluation of the chosen characteristic by means of a Giant
   Language Mannequin (LLM).
3. Have area consultants evaluate the generated evaluation, making certain it’s
   correct, aligns with current challenge conventions and architectural tips.
   If the characteristic shouldn’t be sufficiently remoted for migration, defer it and replace
   the characteristic record accordingly.
4. Proceed with LLM-assisted rebuild of the validated characteristic to the goal
   system or framework.
5. Till the record is empty, return to #2

Earlier than Getting Began

Earlier than we proceed with the workflow, it’s important to have a
high-level understanding of the present codebase and decide which
elements needs to be retained, discarded, or deferred for future
consideration.

Within the context of Bahmni, Show
Controls
are modular, configurable widgets that may be embedded throughout numerous
pages to reinforce the system’s flexibility. Their decoupled nature makes
them well-suited for focused modernization efforts. Bahmni at the moment
consists of over 30 show controls developed over time. These controls are
extremely configurable, permitting healthcare suppliers to tailor the interface
to show pertinent knowledge like diagnoses, remedies, lab outcomes, and
extra. By leveraging show controls, Bahmni facilitates a customizable
and streamlined person expertise, aligning with the various wants of
healthcare settings.

All the present Bahmni show controls are constructed over OpenMRS REST
endpoint, which is tightly coupled with the OpenMRS knowledge mannequin and
particular implementation logic. OpenMRS (Open
Medical Document System) is an open-source platform designed to function a
foundational EMR system primarily for low-resource environments offering
customizable and scalable methods to handle well being knowledge, particularly in
creating international locations. Bahmni is constructed on prime of OpenMRS, counting on
OpenMRS for scientific knowledge modeling and affected person report administration, utilizing
its APIs and knowledge constructions. When somebody makes use of Bahmni, they’re
primarily utilizing OpenMRS as half of a bigger system.

FHIR (Quick Healthcare
Interoperability Sources) is a contemporary customary for healthcare knowledge
trade, designed to simplify interoperability through the use of a versatile,
modular method to symbolize and share scientific, administrative, and
monetary knowledge throughout programs. FHIR was launched by
HL7 (Well being Stage Seven Worldwide), a
not-for-profit requirements improvement group that performs a pivotal
function within the healthcare trade by creating frameworks and requirements for
the trade, integration, sharing, and retrieval of digital well being
info. The time period “Well being Stage Seven” refers back to the seventh layer
of the OSI (Open Programs
Interconnection) mannequin—the applying
layer,
chargeable for managing knowledge trade between distributed programs.

Though FHIR was initiated in 2011, it reached a major milestone
in December 2018 with the discharge of FHIR Launch 4 (R4). This launch
launched the primary normative content material, marking FHIR’s evolution right into a
steady, production-ready customary appropriate for widespread adoption.

Bahmni’s improvement commenced in early 2013, throughout a time when FHIR
was nonetheless in its early phases and had not but achieved normative standing.
As such, Bahmni relied closely on the mature and production-proven OpenMRS
REST API. Given Bahmni’s dependence on OpenMRS, the provision of FHIR
assist in Bahmni was inherently tied to OpenMRS’s adoption of FHIR. Till
just lately, FHIR assist in OpenMRS remained restricted, experimental, and
lacked complete protection for a lot of important useful resource varieties.

With the current developments in FHIR assist inside OpenMRS, a key
precedence within the ongoing migration effort is to architect the goal system
utilizing FHIR R4. Leveraging FHIR endpoints facilitates standardization,
enhances interoperability, and simplifies integration with exterior
programs, aligning the system with globally acknowledged healthcare knowledge
trade requirements.

For the aim of this experiment, we’ll focus particularly on the
Therapies Show Management as a consultant candidate for
migration.

Determine 2: Legacy Therapies Show Management constructed utilizing
Angular and built-in with OpenMRS REST endpoints

The Remedy Particulars Management is a particular kind of show management
in Bahmni that focuses on presenting complete details about a
affected person’s prescriptions or drug orders over a configurable variety of
visits. This management is instrumental in offering clinicians with a
consolidated view of a affected person’s therapy historical past, aiding in knowledgeable
decision-making. It retrieves knowledge by way of a REST API, processing it right into a
view mannequin for UI rendering in a tabular format, supporting each present
and historic remedies. The management incorporates error dealing with, empty
state administration, and efficiency optimizations to make sure a sturdy and
environment friendly person expertise.

The information for this management is sourced from the
/openmrs/ws/relaxation/v1/bahmnicore/drugOrders/prescribedAndActive endpoint,
which returns visitDrugOrders. The visitDrugOrders array incorporates
detailed entries that hyperlink drug orders to particular visits, together with
metadata in regards to the supplier, drug idea, and dosing directions. Every
drug order consists of prescription particulars corresponding to drug title, dosage,
frequency, period, administration route, begin and cease dates, and
customary code mappings (e.g., WHOATC, CIEL, SNOMED-CT, RxNORM).

Here’s a pattern JSON response from Bahmni’s
/bahmnicore/drugOrders/prescribedAndActive REST API endpoint containing
detailed details about a affected person’s drug orders throughout a particular
go to, together with metadata like drug title, dosage, frequency, period,
route, and prescribing supplier.

{
  "visitDrugOrders": [
    {
      "visit": {
        "uuid": "3145cef3-abfa-4287-889d-c61154428429",
        "startDateTime": 1750033721000
      },
      "drugOrder": {
        "concept": {
          "uuid": "70116AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
          "name": "Acetaminophen",
          "dataType": "N/A",
          "shortName": "Acetaminophen",
          "units": null,
          "conceptClass": "Drug",
          "hiNormal": null,
          "lowNormal": null,
          "set": false,
          "mappings": [
            {
              "code": "70116",
              "name": null,
              "source": "CIEL"
            },y
            /* Response Truncated */
          ]
        },
        "directions": null,
        "uuid": "a8a2e7d6-50cf-4e3e-8693-98ff212eee1b",

        "orderType": "Drug Order",
        "accessionNumber": null,
        "orderGroup": null,
        "dateCreated": null,
        "dateChanged": null,
        "dateStopped": null,
        "orderNumber": "ORD-1",
        "careSetting": "OUTPATIENT",
        "motion": "NEW",
        "commentToFulfiller": null,
        "autoExpireDate": 1750206569000,
        "urgency": null,
        "previousOrderUuid": null,
        "drug": {
          "title": "Paracetamol 500 mg",
          "uuid": "e8265115-66d3-459c-852e-b9963b2e38eb",
          "type": "Pill",
          "power": "500 mg"
        },
        "drugNonCoded": null,
        "dosingInstructionType": "org.openmrs.module.bahmniemrapi.drugorder.dosinginstructions.FlexibleDosingInstructions",
        "dosingInstructions": {
          "dose": 1.0,
          "doseUnits": "Pill",
          "route": "Oral",
          "frequency": "Twice a day",
          "asNeeded": false,
          "administrationInstructions": "{"directions":"As directed"}",
          "amount": 4.0,
          "quantityUnits": "Pill",
          "numberOfRefills": null
        },
        "dateActivated": 1750033770000,
        "scheduledDate": 1750033770000,
        "effectiveStartDate": 1750033770000,
        "effectiveStopDate": 1750206569000,
        "orderReasonText": null,
        "period": 2,
        "durationUnits": "Days",
        "voided": false,
        "voidReason": null,
        "orderReasonConcept": null,
        "sortWeight": null,
        "conceptUuid": "70116AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
      },
      "supplier": {
        "uuid": "d7a67c17-5e07-11ef-8f7c-0242ac120002",
        "title": "Tremendous Man",
        "encounterRoleUuid": null
      },
      "orderAttributes": null,
      "retired": false,
      "encounterUuid": "fe91544a-4b6b-4bb0-88de-2f9669f86a25",
      "creatorName": "Tremendous Man",
      "orderReasonConcept": null,
      "orderReasonText": null,
      "dosingInstructionType": "org.openmrs.module.bahmniemrapi.drugorder.dosinginstructions.FlexibleDosingInstructions",
      "previousOrderUuid": null,
      "idea": {
        "uuid": "70116AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA",
        "title": "Acetaminophen",
        "dataType": "N/A",
        "shortName": "Acetaminophen",
        "models": null,
        "conceptClass": "Drug",
        "hiNormal": null,
        "lowNormal": null,
        "set": false,
        "mappings": [
          {
            "code": "70116",
            "name": null,
            "source": "CIEL"
          },
          /* Response Truncated */
        ]
      },
      "sortWeight": null,
      "uuid": "a8a2e7d6-50cf-4e3e-8693-98ff212eee1b",
      "effectiveStartDate": 1750033770000,
      "effectiveStopDate": 1750206569000,
      "orderGroup": null,
      "autoExpireDate": 1750206569000,
      "scheduledDate": 1750033770000,
      "dateStopped": null,
      "directions": null,
      "dateActivated": 1750033770000,
      "commentToFulfiller": null,
      "orderNumber": "ORD-1",
      "careSetting": "OUTPATIENT",
      "orderType": "Drug Order",
      "drug": {
        "title": "Paracetamol 500 mg",
        "uuid": "e8265115-66d3-459c-852e-b9963b2e38eb",
        "type": "Pill",
        "power": "500 mg"
      },
      "dosingInstructions": {
        "dose": 1.0,
        "doseUnits": "Pill",
        "route": "Oral",
        "frequency": "Twice a day",
        "asNeeded": false,
        "administrationInstructions": "{"directions":"As directed"}",
        "amount": 4.0,
        "quantityUnits": "Pill",
        "numberOfRefills": null
      },
      "durationUnits": "Days",
      "drugNonCoded": null,
      "motion": "NEW",
      "period": 2
    }
  ]
}

The /bahmnicore/drugOrders/prescribedAndActive mannequin differs considerably
from the OpenMRS FHIR
MedicationRequest
mannequin in each construction and illustration. Whereas the Bahmni REST mannequin is
tailor-made for UI rendering with visit-context grouping and consists of
OpenMRS-specific constructs like idea, drug, orderNumber, and versatile
dosing directions, the FHIR MedicationRequest mannequin adheres to worldwide
requirements with a normalized, reference-based construction utilizing sources corresponding to
Treatment, Encounter, Practitioner, and coded parts in
CodeableConcept and Timing.

Analysis

The “Analysis” section of the method includes producing an
MCP-augmented LLM evaluation of the chosen Show Management. This section is
centered round understanding the legacy system’s habits by inspecting
its supply code and conducting reverse engineering. Such evaluation is
important for informing the ahead engineering efforts. Whereas not all
recognized necessities could also be carried ahead—significantly in long-lived
programs the place sure functionalities might have change into out of date—it’s
important to have a transparent understanding of current behaviors. This allows
groups to make knowledgeable selections about which parts to retain, discard,
or redesign within the goal system, making certain that the modernization effort
aligns with present enterprise wants and technical targets.

At this stage, it’s useful to take a step again and think about how human
builders sometimes method a migration of this nature. One key perception
is that migrating from Angular to React depends closely on contextual
understanding. Builders should draw upon numerous dimensions of information
to make sure a profitable and significant transition. The important areas of
focus sometimes embody:

• Function Analysis: understanding the practical intent and function of the
  current Angular elements throughout the broader utility.
• Knowledge Mannequin Evaluation: reviewing the underlying knowledge constructions and their
  relationships to evaluate compatibility with the brand new structure.
• Knowledge Movement Mapping: tracing how knowledge strikes from backend APIs to the
  frontend UI to make sure continuity within the person expertise.
• FHIR Mannequin Alignment: figuring out whether or not the present knowledge mannequin will be
  mapped to an HL7 FHIR-compatible construction, the place relevant.
• Comparative Evaluation: evaluating structural and practical similarities,
  variations, and potential gaps between the outdated and goal implementations.
• Efficiency Concerns: making an allowance for areas for efficiency
  enhancement within the new system.
• Characteristic Relevance: assessing which options needs to be carried ahead,
  redesigned, or deprecated primarily based on present enterprise wants.

This context-driven evaluation is commonly probably the most difficult facet of
any legacy migration. Importantly, modernization shouldn’t be merely about
changing outdated applied sciences—it’s about reimagining the way forward for the
system and the enterprise it helps. It includes the evolution of the
utility throughout its total lifecycle, together with its structure, knowledge
constructions, and person expertise.

The experience of subject material consultants (SMEs) and area specialists
is essential to grasp current habits and to organize a information for the
migration. And what higher method to seize the anticipated habits than
by means of well-defined take a look at situations in opposition to which the migrated code will
be evaluated. Understanding what situations are to be examined is important
not simply in ensuring that – every thing that used to work nonetheless works
and the brand new habits would work as anticipated but in addition as a result of now your LLM
has a clearly outlined set of targets that it is aware of is what’s anticipated. By
defining these targets explicitly, we will make the LLM’s responses as
deterministic as attainable, avoiding the unpredictability of probabilistic
responses and making certain extra dependable outcomes through the migration
course of.

Based mostly on this understanding, I developed a complete and
strategically structured immediate
designed to seize all related info successfully.

Whereas the immediate covers all anticipated areas—corresponding to knowledge move,
configuration, key features, and integration—it additionally consists of a number of
sections that warrant particular point out:

• FHIR Compatibility: this part maps the customized Bahmni knowledge mannequin
  to HL7 FHIR sources and highlights gaps, thereby supporting future
  interoperability efforts. Finishing this mapping requires a strong understanding
  of FHIR ideas and useful resource constructions, and generally is a time-consuming process. It
  sometimes includes a number of hours of detailed evaluation to make sure correct
  alignment, compatibility verification, and identification of divergences between
  the OpenMRS and FHIR medicine fashions, which might now be carried out in a matter of
  seconds.
• Testing Tips for React + TypeScript Implementation Over OpenMRS
  FHIR: this part affords structured take a look at situations that emphasize knowledge
  dealing with, rendering accuracy, and FHIR compliance for the modernized frontend
  elements. It serves as a superb basis for the event course of,
  setting out a compulsory set of standards that the LLM ought to fulfill whereas
  rebuilding the part.
• Customization Choices: this outlines accessible extension factors and
  configuration mechanisms that improve maintainability and adaptableness throughout
  numerous implementation situations. Whereas a few of these choices are documented,
  the LLM-generated evaluation usually uncovers extra customization paths
  embedded within the codebase. This helps establish legacy customization approaches
  extra successfully and ensures a extra exhaustive understanding of present
  capabilities.

To assemble the required knowledge, I utilized two light-weight servers:

• An Atlassian MCP server to extract any accessible documentation on the
  show management.
• A filesystem MCP server, the place the legacy frontend code and configuration
  had been mounted, to supply supply code-level evaluation.

Determine 3: MCP + Cline + Claude Setup Diagram

Whereas elective, this filesystem server allowed me to deal with the goal
system’s code inside my IDE, with the legacy reference codebases conveniently
accessible by means of the mounted server.

These mild weight servers every expose particular capabilities by means of the
standardized Mannequin Context Protocol, which is then utilized by Cline (my shopper in
this case) to entry the code base, documentation and configuration. For the reason that
configurations shipped are opinionated and the paperwork usually outdated, I added
particular directions to take the supply code as the only supply of fact and
the remaining as a supplementary reference.

Assessment

The second section of the method —is the place the human within the loop
turns into invaluable.

The AI-generated evaluation is not supposed to be accepted at face worth,
particularly for advanced codebases. You’ll nonetheless want a website skilled and an
architect to vet, contextualize, and information the migration course of. AI alone
is not going emigrate a complete challenge seamlessly; it requires
considerate decomposition, clear boundaries, and iterative validation.

Not all these necessities will essentially be integrated into the
goal system, for instance the flexibility to print a prescription sheet primarily based
on the drugs prescribed is deferred for now.

On this case, I augmented the evaluation with pattern responses from the
FHIR endpoint and whereas discarding elements of the system that aren’t
related to the modernization effort. This consists of efficiency
optimizations, take a look at instances that aren’t instantly related to the migration,
and configuration choices such because the variety of rows to show and
whether or not to point out energetic or inactive drugs. I felt these will be
addressed as a part of the subsequent iteration.

As an example, think about the unit take a look at situations outlined for rendering
therapy knowledge:

        ✅ Blissful Path

        It ought to accurately render the drugName column.
        It ought to accurately render the standing column with the suitable Tag coloration.
        It ought to accurately render the precedence column with the proper precedence Tag.
        It ought to accurately render the supplier column.
        It ought to accurately render the startDate column.
        It ought to accurately render the period column.
        It ought to accurately render the frequency column.
        It ought to accurately render the route column.
        It ought to accurately render the doseQuantity column.
        It ought to accurately render the instruction column.

        ❌ Unhappy Path

        It ought to present a “-” if startDate is lacking.
        It ought to present a “-” if frequency is lacking.
        It ought to present a “-” if route is lacking.
        It ought to present a “-” if doseQuantity is lacking.
        It ought to present a “-” if instruction is lacking.
        It ought to deal with instances the place the row knowledge is undefined or null.
      

Changing lacking values with “-” within the unhappy path situations has been eliminated,
because it doesn’t align with the necessities of the goal system. Such selections
needs to be guided by enter from the subject material consultants (SMEs) and
stakeholders, making certain that solely performance related to the present enterprise
context is retained.

The literature gathered on the show management now must be coupled with
challenge conventions, practices, and tips with out which the LLM is open to
interpret the above request, on the information that it was educated with. This consists of
entry to features that may be reused, pattern knowledge fashions and companies and
reusable atomic elements that the LLMs can now depend on. If such practices,
type guides and tips will not be clearly outlined, each iteration of the
migration dangers producing non-conforming code. Over time, this could contribute to
a fragmented codebase and an accumulation of technical debt.

The core goal is to outline clear, project-specific coding requirements and
type guides to make sure consistency within the generated code. These requirements act as
a foundational reference for the LLM, enabling it to provide output that aligns
with established conventions. For instance, the Google TypeScript Type Information can
be summarized and documented as a TypeScript type information saved within the goal
codebase. This file is then learn by Cline firstly of every session to make sure
that every one generated TypeScript code adheres to a constant and acknowledged
customary.

Rebuild

Rebuilding the characteristic for a goal system with LLM-generated code is
the ultimate section of the workflow. Now with all of the required knowledge gathered,
we will get began with a easy immediate

You might be tasked with constructing a Remedy show management within the new react ts fhir frontend. Yow will discover the main points of the legacy Remedy show management implementation in docs/treatments-legacy-implementation.md. Create the brand new show management by following the docs/display-control-guide.md

At this stage, the LLM generates the preliminary code and take a look at situations,
leveraging the knowledge offered. As soon as this output is produced, it’s
important for area consultants and builders to conduct an intensive code evaluate
and apply any needed refactoring to make sure alignment with challenge requirements,
performance necessities, and long-term maintainability.

Refactoring the LLM-generated code is important to making sure the code stays
clear and maintainable. With out correct refactoring, the end result may very well be a
disorganized assortment of code fragments moderately than a cohesive, environment friendly
system. Given the probabilistic nature of LLMs and the potential discrepancies
between the generated code and the unique goals, it’s important to
contain area consultants and SMEs at this stage. Their function is to totally
evaluate the code, validate that the output aligns with the preliminary expectations,
and assess whether or not the migration has been efficiently executed. This skilled
involvement is essential to make sure the standard, accuracy, and general success of
the migration course of.

This section needs to be approached as a complete code evaluate—just like
reviewing the work of a senior developer who possesses robust language and
framework experience however lacks familiarity with the precise challenge context.
Whereas technical proficiency is crucial, constructing strong programs requires a
deeper understanding of domain-specific nuances, architectural selections, and
long-term maintainability. On this context, the human-in-the-loop performs a
pivotal function, bringing the contextual consciousness and system-level understanding
that automated instruments or LLMs might lack. It’s a essential course of to make sure that
the generated code integrates seamlessly with the broader system structure
and aligns with project-specific necessities.

In our case, the intent and context of the rebuild had been clearly outlined,
which minimized the necessity for post-review refactoring. The necessities gathered
through the analysis section—mixed with clearly articulated challenge conventions,
know-how stack, coding requirements, and magnificence guides—ensured that the LLM had
minimal ambiguity when producing code. Consequently, there was little left for
the LLM to deduce independently.

That stated, any unresolved questions concerning the implementation plan can
result in deviations from the anticipated output. Whereas it isn’t possible to
anticipate and reply each such query prematurely, it is very important
acknowledge the inevitability of “unknown unknowns.” That is exactly the place a
thorough evaluate turns into important.

On this specific occasion, my familiarity with the show management we had been
rebuilding allowed me to proactively reduce such unknowns. Nevertheless, this degree
of context might not at all times be accessible. Due to this fact, I strongly suggest
conducting an in depth code evaluate to assist uncover these hidden gaps. If
recurring points are recognized, the immediate can then be refined to handle them
preemptively in future iterations.

The attract of LLMs is plain; they provide a seemingly easy answer
to advanced issues, and builders can usually create such an answer shortly and
without having years of deep coding expertise. This could not create a bias
within the consultants, succumbing to the attract of LLMs and ultimately take their palms
off the wheel.

End result

Determine 4: A excessive degree overview of the method; taking a characteristic from the legacy codebase and utilizing LLM-assisted evaluation to rebuild it throughout the goal system

In my case the code technology course of took about 10 minutes to
full. The evaluation and implementation, together with each unit and
integration exams with roughly 95% protection, had been accomplished utilizing
Claude 3.5 Sonnet (20241022). The full value for this effort was about
$2.

Determine 5: Legacy Therapies Show Management constructed utilizing Angular and built-in with OpenMRS REST endpoints

Determine 6: Modernized Therapies Show Management rebuilt
utilizing React and TypeScript, leveraging FHIR endpoints

With out AI assist, each the technical evaluation and implementation
would have seemingly taken a developer a minimal of two to 3 days. In my
case, creating a reusable, general-purpose immediate—grounded within the shared
architectural rules behind the roughly 30 show controls in
Bahmni—took about 5 targeted iterations over 4 hours, at a barely
increased inference value of round $10 throughout these cycles. This effort was
important to make sure the generated immediate was modular and broadly
relevant, given that every show management in Bahmni is basically a
configurable, embeddable widget designed to reinforce system flexibility
throughout totally different scientific dashboards.

Even with AI-assisted technology, one of many key prices in improvement
stays the time and cognitive load required to investigate, evaluate, and
validate the output. Due to my prior expertise with Bahmni, I used to be in a position
to evaluate the generated evaluation in below quarter-hour, supplementing it
with fast parallel analysis to validate the claims and knowledge mappings. I
was pleasantly stunned by the standard of the evaluation: the information mannequin
mapping was exact, the logic for transformation was sound, and the take a look at
case strategies lined a complete vary of situations, each typical
and edge instances.

Code evaluate, nevertheless, emerged as probably the most vital problem.
Reviewing the generated code line by line throughout all modifications took me
roughly 20 minutes. In contrast to pairing with a human developer—the place
iterative discussions happen at a manageable tempo—working with an AI system
able to producing total modules inside seconds creates a bottleneck
on the human facet, particularly when trying line-by-line scrutiny. This
isn’t a limitation of the AI itself, however moderately a mirrored image of human
evaluate capability. Whereas AI-assisted code reviewers are sometimes proposed as a
answer, they will usually establish syntactic points, adherence to finest
practices, and potential anti-patterns—however they wrestle to evaluate intent,
which is important in legacy migration tasks. This intent, grounded in
area context and enterprise logic, should nonetheless be confirmed by the human in
the loop.

For a legacy modernization challenge involving a migration from AngularJS
to React, I’d fee this expertise an absolute 10/10. This functionality
opens up the likelihood for any people with first rate technical
experience and powerful area data emigrate any legacy codebase to a
trendy stack with minimal effort and in considerably much less time.

I imagine that with a bottom-up method, breaking the issue down
into atomic elements, and clearly defining finest practices and
tips, AI-generated code may vastly speed up supply
timelines—even for advanced brownfield tasks as we noticed for Bahmni.

The preliminary evaluation and the next evaluate by consultants leads to a
crisp sufficient doc that lets us use the restricted area within the context
window in an environment friendly approach so we will match extra info into one single
immediate. Successfully, this enables the LLM to investigate code in a approach that’s
not restricted by how the code is organized within the first place by builders.
This additionally leads to lowering the general value of utilizing LLMs, as a brute
drive method would imply that you just spend 10 instances as a lot even for a a lot
easier challenge.

Whereas modernizing the legacy codebase is the primary product of this
proposed method, it isn’t the one beneficial one. The documentation
generated in regards to the system is effective when offered not simply to the tip
customers / implementers in complementing or filling gaps in current programs
documentation and in addition would stand in as a data base in regards to the system
for ahead engineering groups pairing with LLMs to reinforce or enrich
system capabilities.

Why the Assessment Section Issues

A key enabler of this profitable migration was a well-structured plan
and detailed scope evaluate section previous to implementation. This early
funding paid dividends through the code technology section. And not using a
clear understanding of the information move, configuration construction, and
show logic, the AI would have struggled to provide coherent and
maintainable outputs. When you have labored with AI earlier than, you could have
seen that it’s constantly desirous to generate output. In an earlier
try, I proceeded with out ample warning and skipped the evaluate
step—solely to find that the generated code included a useMemo hook
for an operation that was computationally trivial. One of many success
standards within the generated evaluation was that the code needs to be
performant, and this seemed to be the AI’s approach of fulfilling that
requirement.

Apparently, the AI even added unit exams to validate the
efficiency of that particular operation. Nevertheless, none of this was
explicitly required. It arose solely attributable to a poorly outlined intent. AI
integrated these modifications with out hesitation, regardless of not absolutely
understanding the underlying necessities or searching for clarification.
Reviewing each the generated evaluation and the corresponding code ensures
that unintended additions are recognized early and that deviations from
the unique expectations are minimized.

Assessment additionally performs a key function in avoiding pointless back-and-forth
with the AI through the rebuild section. As an example, whereas refining the
immediate for the “Show Management Implementation
Information”,
I initially didn’t have the part specifying the unit exams to be
included. Consequently, the AI generated a take a look at that was largely
meaningless—providing a false sense of take a look at protection with no actual
connection to the code below take a look at.

Determine 7: AI generated unit take a look at that verifies actuality
remains to be actual

In an try to repair this take a look at, I started prompting
extensively—offering examples and detailed directions on how the unit
take a look at needs to be structured. Nevertheless, the extra I prompted, the additional the
course of deviated from the unique goal of rebuilding the show
management. The main target shifted solely to resolving unit take a look at points, with
the AI even starting to evaluate unrelated exams within the codebase and
suggesting fixes for issues it recognized there.

Ultimately, realizing the growing divergence from the supposed
process, I restarted the method with clearly outlined directions from the
outset, which proved to be far simpler.

This leads us to an important perception: Do not Interrupt AI.

LLMs, at their core, are predictive sequence turbines that construct
narratives token by token. Whenever you interrupt a mannequin mid-stream to
course-correct, you break the logical move it was setting up.
Stanford’s “Misplaced within the
Center”
examine revealed that fashions can endure as much as a 20%
drop in accuracy when important info is buried in the course of
lengthy contexts, versus when it’s clearly framed upfront. This underscores
why beginning with a well-defined immediate and letting the AI full its
process unimpeded usually yields higher outcomes than fixed backtracking or
mid-flight corrections.

This concept can be strengthened in “Why Human Intent Issues Extra as AI
Capabilities Develop” by Nick
Baumann,
which argues that as mannequin capabilities scale, clear human intent—not
simply brute mannequin power—turns into the important thing to unlocking helpful output.
Relatively than micromanaging each response, practitioners profit most by
designing clear, unambiguous setups and letting the AI full the arc
with out interruption.

Conclusion

You will need to make clear that this method shouldn’t be supposed to be a
silver bullet able to executing a large-scale migration with out
oversight. Relatively, its power lies in its capability to considerably
scale back improvement time—doubtlessly by a number of weeks—whereas sustaining
high quality and management.

The objective is not to interchange human experience however to amplify it—to
speed up supply timelines whereas making certain that high quality and
maintainability are preserved, if not improved, through the transition.

It is usually vital to notice that the expertise and outcomes mentioned
to this point are restricted to read-only controls. Extra advanced or interactive
elements might current extra challenges that require additional
analysis and refinement of the prompts used.

One of many key insights from exploring GenAI for legacy migration is
that whereas massive language fashions (LLMs) excel at general-purpose duties and
predefined workflows, their true potential in large-scale enterprise
transformation is simply realized when guided by human experience. That is
nicely illustrated by Moravec’s Paradox, which observes that duties perceived
as intellectually advanced—corresponding to logical reasoning—are comparatively simpler
for AI, whereas duties requiring human instinct and contextual
understanding stay difficult. Within the context of legacy modernization,
this paradox reinforces the significance of subject material consultants (SMEs)
and area specialists, whose deep expertise, contextual understanding,
and instinct are indispensable. Their experience allows extra correct
interpretation of necessities, validation of AI-generated outputs, and
knowledgeable decision-making—in the end making certain that the transformation is
aligned with the group’s targets and constraints.

Whereas project-specific complexities might render this method formidable,
I imagine that by adopting this structured workflow, AI-generated code can
considerably speed up supply timelines—even within the context of advanced
brownfield tasks. The intent is to not change human experience, however to
increase it—streamlining improvement whereas safeguarding, and doubtlessly
enhancing, code high quality and maintainability. Though the standard and
architectural soundness of the legacy system stay important elements, this
methodology affords a powerful start line. It reduces handbook overhead,
creates ahead momentum, and lays the groundwork for cleaner and extra
maintainable implementations by means of expert-led, guided refactoring.

I firmly imagine following this workflow opens up the likelihood for
any people with first rate technical experience and powerful area
data emigrate any legacy codebase to a contemporary stack with minimal
effort and in considerably much less time.