Integrating ChatGPT with Low‑Code Platforms for Accelerated Software Development

After the emergence of GPT, many speculate that software will be rewritten. This article explores the combination of low‑code platforms with ChatGPT, aiming to speed up development.

Background : The author questions whether software can be generated in a simpler, more human‑friendly way. Previous attempts at model‑driven development showed limitations; human input is still needed.

Demo : A demonstration shows a tool that extracts Chinese class, member, and method names from a domain model, translates them via ChatGPT, and fills them back into the tool to generate code.

Using ChatGPT's translation ability dramatically reduces the effort of translating dozens of class and method names.

Thought Process includes three modes:

1. Direct software generation – ChatGPT writes a complete program (e.g., a snake game) but is limited by domain knowledge and team conventions.

2. Code snippet generation – ChatGPT generates code fragments based on context, similar to Copilot.

3. DSL generation – ChatGPT produces a domain‑specific language, which is then used by the tool to generate code; this yields more stable results.

Current status of ChatGPT code generation :

Can understand code, add comments, and optimize naming.

Can guess functionality from a function signature.

Generates generic code well, but domain‑specific code may not follow best practices.

Quality depends on prompt quality; too much or too little input degrades results.

Practical constraints include input length limits, time cost, and potential sensitive data leakage.

Feasible ideas :

Use ChatGPT to assist DSL generation, then feed DSL to low‑code platform.

Let ChatGPT fill missing code fragments after the tool generates skeletons.

Example case: extracting information from a sequence diagram to generate pseudo‑code, then converting it to C++ via DSL and ChatGPT.

int 泊位::来车(){
  // 1、取值班人员
  排班(时间).取值班人员(值班人员序号);
  if(失败){
    打印日志
    return 失败错误码;
  }
  return 0;
}

After translation and enrichment, the DSL JSON is:

{
  "return_type":"int",
  "function_name":"ArriveCar",
  "param":[],
  "impl":[
    {
      "entity":"Scheduling",
      "function":"GetShiftPersonnel",
      "return_type":"int",
      "param":[{"type":"int","name":"number"}]
    }
  ]
}

The final generated C++ snippet (with placeholders) is:

// 来车
int ParkingSpace::ArriveCar() {
  //// MDD-TAG-BEGIN:[flow][slot-ArriveCar][函数实现]
  int ret = 0;
  // 取值班人员
  Scheduling scheduling (time(nullptr));
  ret = scheduling.GetAttendant(number_);
  if (ret != 0) {
    LOG_VERR("GetAttendant", ret, number_);
    return ret;
  }
  return ret;
  //// MDD-TAG-END:[flow][slot-ArriveCar]
}

The design of the code‑generation engine includes a protocol stack defining the input format, modular plugins (code‑generation plugin, translation plugin, test‑generation plugin, etc.), and a layered architecture (architecture layer, plugin layer, tool layer).

Evaluation suggests that the approach can save over 90 % of manual coding effort, leaving about 10 % for code review, manual adjustments, and unit‑test creation.

Conclusion: AI tools like ChatGPT are meant to assist developers, not replace them. Proper integration can significantly accelerate development while keeping human oversight for complex or sensitive parts.