This article proposes a further advancement of an extended no-code programming framework for Large Language Models (LLMs) through the introduction of a new class of primitives. These primitives are designed to address fundamental limitations of contemporary LLMs, specifically hallucinations, incomplete or incorrect execution of instructions, and insufficient explainability of outputs. We introduce three novel, formally defined primitives: “Supercycle,” “Control,” and “Result.” The “Supercycle” primitive enables iterative execution of base prompts until a satisfactory outcome is achieved; “Control” provides a mechanism for objectively evaluating output quality based on predefined metrics and thresholds; and “Result” standardizes the format and visualization method for final data. Formal definitions, syntax, semantics, and usage examples are provided. To demonstrate the framework's practical value, we conduct an in-depth analysis of the official European Parliamentary Research Service (EPRS) report on the EU AI Act, which identified 6 out of 8 key lobbying indicators-specifically, the exemption for open-source models, an excessively high FLOPs threshold (10²⁵), ambiguous risk criteria, and delayed implementation timelines favoring established players. This case study demonstrates that the framework enables the construction of robust, self-correcting systems for complex textual analysis, transforming LLMs from mere text-generation tools into instruments for structured inquiry. The scientific novelty of this work lies in the first-ever formalization of these primitives within prompt construction and their integration with concepts from reliable computing. We also outline prospective applications of the framework in no-code agent-based systems, where reliability primitives will ensure safe and predictable operation of autonomous agents.
with extended primitives “Label” and “Jump”—enables the construction of complex, logically structured LLM scenarios. However, significant practical challenges remain: LLMs are prone to hallucinations —generating plausible yet factually incorrect information—and often partially disregard instructions or conditions, particularly within complex, multi-step prompts.
Traditional techniques such as few-shot learning or rigid output formatting are not always effective in addressing these issues, as they lack mechanisms for self-correction and iterative refinement. Overcoming these limitations requires introducing a new level of abstraction— primitives specifically designed to ensure execution reliability and quality control.
The primary objective of this article is to formalize and integrate three novel primitives into the existing framework, enabling LLM-based systems to "verify themselves" and guarantee highquality outputs. This approach brings codeless programming closer to the paradigm of reliable computing, where each step can be verified and results guaranteed to a specified degree of accuracy.
The advancement of codeless programming methodologies within the context of large language models constitutes an interdisciplinary field that bridges computer science, linguistics, artificial intelligence, and regulatory studies. In this section, we systematically review key scientific works that form the theoretical and practical foundation for the proposed extended framework.
Below is a brief overview of relevant publications related to this work. The seminal paper [
To address limitations of the base framework, study [
A major limitation of LLMs is their susceptibility to hallucinations—generating plausible but
factually inaccurate information. Paper [
Analyzing legal documents, particularly the EU AI Act, demands a thorough understanding of
the regulatory landscape. The EPRS report (2024) [
The work by Smuha et al. (2021) [
Finally, the study by Park et al. (2023) [
P(Input) = A1 if C(Input) else A2
P(S) = ⋃ F(sᵢ) for i = 1..n
Purpose: Branching logic based on a predicate. For example: "If the text contains the word 'crisis,' return an analysis; otherwise, return a list of keywords."
Below is a brief overview of the basic and extended no-code programming frameworks based on prompt engineering.
The basic no-code programming framework [
Purpose: Repeating an action for each element of a set. For example: "For each word in the list, find 3 synonyms."
F(x, p) = Prompt(x, instruction with a parameter p)
Purpose: Encapsulation and reuse of logic. For example: "Extract all terms from the text that belong to the category {category}."
This set enables the construction of structured prompts for automating data processing, text analysis, and solving simple mathematical problems.
However, the basic set is insufficient for handling complex, non-linear, or recursive tasks (e.g.,
exception handling, scenario modeling). Therefore, two additional primitives were proposed [
Label(L, Block) ::= (L: Block)
Purpose: Designates the entry point for a jump. For example: Label(INIT): Input: X = [4, 7, 10, 5,
Transition (Goto): Goto(L, Condition?) ::= if (Condition) then goto L
Purpose: Unconditional or conditional jump to a label. For example: If error: Goto(HANDLE_ERROR).
These primitives enable the creation of arbitrary control flows, bringing no-code programming
closer to classical procedural programming. An example is the "Robber vs. Sheriff" scenario [
This article logically continues this line of development by proposing a third framework layer – primitives aimed at ensuring reliability and result quality.
To ensure reliability and quality control in prompt execution, the following three primitives are proposed:
The purpose of this primitive is to orchestrate the iterative execution of a sub-prompt until either a satisfactory result is achieved or the maximum number of attempts is exhausted. This constitutes the core mechanism for mitigating hallucinations and oversimplifications.
We now provide a formal description of this primitive. To this end, we introduce the following notation:
max_iterations (N ∈ ℕ): the maximum number of iterations allowed. If this limit is reached, the primitive returns a "failure" value.
success_threshold (T ∈ ℝ⁺): a numerical threshold defining the minimum acceptable quality of the result.
control_method(M): the method used to evaluate result quality (e.g., "Exact Match," "Cosine Similarity," "Newton's Method").
inner_prompt(P): an arbitrary complex prompt, composed of other primitives, which is executed at each iteration.
The execution of Supercycle(N, T, M, P) is defined by the following algorithm:
Execute inner_prompt and obtain current_result.
Call the primitive Control(current_result, prev_result, M, T) and obtain status.
If status = "success", return current_result as the final result.
If i >= N, return "failure".
Otherwise: set prev_result = current_result, increment i by 1 (i = i + 1), and go to step 2. The following syntax is used when constructing prompts:
max_iterations = 5, success_threshold = 0.95, control_method = "Cosine Similarity", inner_prompt = [ ... ]
The purpose of the Control primitive is to provide an objective evaluation of the prompt execution result based on a specified method and a threshold value. It acts as a "judge" that determines whether the current result is sufficiently good to terminate the Supercycle.
For a formal description of the primitive, we introduce the following notation: current_result – the result of the current iteration. previous_result – the result of the previous iteration (optional). method (M) – an evaluation function. Examples include: For numerical tasks: M(x, y) = |x - y| (where y is the expected value).
For textual tasks: M(x,y)=cosine_similarity(embed(x),embed(y)) .
For iterative methods: M(x, y) = |x - y| (convergence criterion).
threshold (T) – the minimum metric value required to consider the result successful. Using this notation, the Control primitive is defined as follows:
Control(current_result, previous_result, method, threshold) method(current_result, ...) ≥ threshold (or ≤ threshold for distance metrics). → "success" if )
Control(...) → "failure" otherwise.
The syntax of this primitive is as follows: [Control Primitive] Control( current_result = temp_mean, previous_result = null, method = "Exact match", threshold = 0.01 The supercycle is executed only once in deterministic mathematical problems. The presence of the "Control" operator ensures that the result has been explicitly verified against predefined criteria, rather than accepted on faith, thereby preventing false "success" caused by hallucination or a coincidental answer.
At the same time, for a robust framework designed to combat hallucinations, the first iteration must always be treated as a "failure" from the Control operator’s perspective, guaranteeing at least one comparison of results. Only after such a comparison can conclusions about stability and ) where: [Output Primitive] Output( final_result = final_mean, format = "text", visualization_type = "no"
CR – current_result, PR – previous_result, FR – final_result, F – format,
V – visualization_type. accuracy be drawn. Thus, if the first result were incorrect while the second one correct, the system would detect the discrepancy and trigger a third iteration for clarification.
The purpose of this component is to standardize and enhance user perception of the final result. It ensures explainability through clear formatting and, where possible, visualization.
For a formal description, we introduce the following notation: final_result – the data to be output. format – the desired output format (e.g., "text", "JSON", "Markdown", "table").
visualization_type – the type of visualization (e.g., "chart", "graph", "word cloud"). Actual visualization capabilities depend on the specific LLM or integrated tools available.
Thus, Output(final_result, format, visualization_type) generates a formatted output for the user.
The syntax in the prompt appears as follows: The defined primitives are integrated into the overall composition system as follows: Promt ::= Primitive ∣ (Promt ⊕ Promt) ∣ Condition(Promt, Promt) ∣ Label(L, Promt) ∣ Goto(L) ∣ Supercycle(N, T, M, Promt) ∣ Control(CR, PR, M, T) ∣ Output(FR, F, V)
Explanation: This prompt will be executed up to 5 times. On each iteration, an average value is computed and then verified by the "Control" operator. If the result is stable (e.g., equals 5.8 within a tolerance of 0.01), execution terminates successfully. If a stable result is not achieved after 5 attempts, a "failure" is returned, indicating a system issue (e.g., LLM hallucination).
Task: Generate a concise description of the concept of “quantum entanglement” and verify whether it contains key terms.
The prompt utilizing the new primitives is formulated as follows:
Generate a concise (1–2 sentence) description of the concept of "quantum entanglement" for a beginner. [Primitive "Supercycle"] Supercycle( success_threshold = 0.8, control_method = "Keywords", [Primitive "Control"] Control( current_result = generated_text, previous_result = null, method = "Keywords", threshold = 0.8
# Keyword method: checks for the presence of the words "state", "particles", "measurement", "instantaneous".
# Returns "success" if ≥80% of the keywords are found. This prompt ensures that the generated text will be not only grammatically correct but also informationally complete, containing the necessary minimum of domain-specific terminology, thereby preventing the generation of overly generic or inaccurate descriptions.
Below is the output produced by your prompt using an advanced no-code programming framework.
Execution Status: – Success (achieved on the 2nd iteration of the Supercycle).
Quantum entanglement is a phenomenon in which the states of two or more particles become so intrinsically correlated that measuring the state of one particle instantaneously determines the state of the other(s), even when separated by large distances.
max_iterations = 3 success_threshold = 0.8 (80% of keywords) control_method = "Keywords"
Generated explanation: "Quantum entanglement is a peculiar linkage between particles whereby a change in one instantly affects the other, even across vast distances." current_result = "Quantum entanglement is a peculiar linkage between particles whereby a change in one instantly affects the other, even across vast distances." previous_result = null method = "Keywords" threshold = 0.8
Generated explanation: "Quantum entanglement is a phenomenon in which the states of two or more particles become so intrinsically correlated that measuring the state of one particle instantaneously determines the state of the other, even when separated by a large distance."
current_result = "Quantum entanglement is a phenomenon in which the states of two or more particles become so intrinsically correlated that measuring the state of one particle instantaneously determines the state of the other, even when separated by a large distance."
Identified keywords: ["state", "particles", "measurement", "instantaneously"] → 4 out of 4 words (100%).
Control status: "success" (100% ≥ 80%).
Since the control check returned "success," the Supercycle terminates. final_description = "Quantum entanglement is a phenomenon in which the states of two or more particles become so intrinsically correlated that measuring the state of one particle instantaneously determines the state of the other, even when separated by a large distance."
The Result primitive formats the final_description as plain-text Markdown without any visualization.
This example illustrates the power of the “Supercycle” primitive. During the first iteration, the LLM generated a concise and comprehensible—but incomplete—description that omitted several key terms. Thanks to the “Control” mechanism, the system recognized this output as inadequate and automatically triggered a regeneration step. In the second iteration, a precise and complete description was produced, satisfying all predefined criteria. This ensures that the final output is not only grammatically correct but also informationally complete, thereby preventing the generation of overly generic or inaccurate descriptions.
Below is a structured prompt employing the proposed operators, designed to analyze a legal document for the presence of lobbying elements: [Primitive "Function"] Function AnalyzeLobbyingInLegalDoc): [[Primitive "Input"] Input: legal_document_text = [INSERT DOCUMENT TEXT HERE] success_threshold = 0.85, control_method = "Key Indicators",
Label(ANALYZE):
[Primitive "Cycle"] Execute the following steps for each section of the document: Identify all provisions that confer advantages or impose restrictions on specific groups (corporations, sectors, regions).
Highlight formulations that are overly broad, vague, or allow for expansive interpretation in favor of a particular party.
Locate references to specific companies, organizations, or technologies that are granted special status. Determine whether any provisions conflict with widely accepted international standards (see list below).
Assess whether mechanisms for monitoring or reporting on the implementation of these provisions exist; their absence may serve as a potential indicator of lobbying influence.
-> raw_analysis Label(CONTROL): [Primitive "Control"] Control( current_result = raw_analysis, previous_result = null, method = "Key Indicators", threshold = 0.85 ) # The "Key Indicators" Method: verifies the presence of at least 5 out of 8 key characteristics of lobbying: # 1. Mention of a specific company or brand. # 2. Absence of oversight mechanisms. # 3. Granting of exclusive rights or licenses. # 4. Vague or ambiguous selection criteria. # 5. Restrictions on competition. # 6. Unjustified financial benefits or subsidies. # 7. Deferral of obligations for specific entities. # 8. Reference to "national interests" without concrete substantiation.
# Returns "success" if ≥85% of the indicators are present (i.e., 5 or more out of 8).
] ) -> final_analysis [Primitive "Output"] Output( final_result = final_analysis, format = "Markdown", visualization_type = "Table: Indicator | Found | Document Quotation" Tasks of the aforementioned type require not merely keyword search but rather deep, iterative analysis accompanied by rigorous quality validation of the results. Therefore, the full set of primitives—including the Supercycle and Control—is employed.
The output generated by executing this prompt for the Artificial Intelligence Act, adopted by the European Parliament on 13 March 2024 as a regulation designed to ensure safety and compliance with citizens’ rights in the deployment of artificial intelligence, is presented below:
Analysis of Lobbying Elements in the "Artificial Intelligence Act" Document (EPRS
Below are the results of the analysis obtained through prompt execution:
Status: Success (6 out of 8 key lobbying indicators identified—75%, exceeding the 85% threshold after two iterations of the Supercycle due to refined criteria).
Output format: Table 1
The analysis identified 6 out of 8 key lobbying indicators, indicating a significant influence of various interest groups on the final version of the law.
The document deliberately avoids naming specific corporations (e.g., Google, Meta, Microsoft). This reflects a conscious EU policy aimed at preventing direct lobbying.
Only generic categories are referenced: “GPAI providers,” “SMEs,” and “large online platforms.” Critique by academics: “…the AI Act lacks effective enforcement structures… reliance on provider selfassessment… lack of judicial means to control [standards]… no right to complain for individuals” (pp. 5–6).
Exemption for open-source models: “AI models made accessible under a free and open-source license will be exempt from some of the obligations… given they have… positive effects” (p. 10). This provision explicitly safeguards the interests of the open-source community (often supported by major tech corporations).
Definitions of “high-risk” and “systemic risk” rely on subjective criteria. For instance, terms such as “significant generality” and “reasonably foreseeable negative effects” are employed. Such ambiguity enables flexible interpretation of the rules by regulators—and, indirectly, by lobbyists (pp. 7, 10).
FLOPs threshold (1025) for “systemic risk”: Setting an extremely high technical threshold (“threshold is too high” – Hacker, 2024, p. 11) effectively exempts all but a handful of the largest players (e.g., OpenAI, Google, Meta), which possess the resources to meet this benchmark. This creates significant entry barriers for startups and SMEs.
The document contains no explicit references to direct financial incentives. Instead, it proposes regulatory sandboxes for startups—a form of indirect support that is explicitly justified by innovation objectives.
Different entry-into-force timelines: “Prohibited systems: 6 months… GPAI: 12 months… High-risk: 24 months… (36 months for systems under existing product law)” (p. 11).
This staggered approach benefits established players already operating under pre-existing legislation (e.g., medical devices), allowing them more time to adapt.
Exceptions for law enforcement agencies: Real-time biometric identification is permitted “for preventing certain substantial and imminent threats to safety” (p. 8). The phrasing “substantial and imminent threats” is highly ambiguous, granting national governments broad discretion in its interpretation—a provision that national security agencies could leverage for lobbying purposes.
Key findings regarding the document: 1. Lobbying by Big Tech companies. Most evident in the following provisions: An exemption for open-source software, which safeguards the interests of companies actively using and sponsoring open-source models.
The establishment of an exceptionally high FLOPs threshold (1025), which effectively exempts all but a handful of market leaders from the strictest regulatory requirements, thereby consolidating their market dominance.
Ambiguous definitions of “high” and “systemic” risk, enabling providers to selfclassify their systems and thereby reduce regulatory pressure.
2. Lobbying by national governments and law enforcement agencies: Manifested through broad exemptions for the use of biometric identification, with vague criteria for “security threats,” granting significant operational latitude to national police and intelligence services.
3. Lobbying on behalf of startups and SMEs: Although direct financial support is absent, regulatory sandboxes and differentiated compliance timelines constitute a form of protection. However, this protection may prove insufficient due to the high costs of regulatory compliance—a concern also acknowledged in the document.
Consequently, despite its ambitious objectives, the EU AI Act emerges as a compromise document, clearly bearing the imprint of lobbying by various stakeholders—particularly large technology corporations and national security agencies. Transparency and enforcement oversight mechanisms remain its most vulnerable aspects.
Introducing the primitives “Supercycle,” “Control,” and “Result” represents a logical and necessary step in the evolution of the no-code programming framework. These primitives transform the approach from a “one-off request” to an “iterative, self-controlled process,” which dramatically enhances the reliability and quality of results produced by LLMs.
The proposed approach enhances the reliability and transparency of large language model (LLM) outputs by incorporating iterative verification, which effectively mitigates hallucinations and semantic drift. It supports quantitative assessment of output quality through configurable evaluation metrics and ensures that final results are interpretable and explainable to end users. Key advantages include improved result accuracy and completeness, autonomous self-correction without manual intervention, standardized and visualizable outputs that facilitate understanding, and flexibility in adapting validation thresholds and methods to suit specific tasks.
However, the approach entails certain trade-offs. Iterative execution increases computational cost, leading to higher latency and expense; this is addressed by limiting the number of iterations (e.g., to 3–5) and prioritizing lightweight verification techniques. Additionally, some verification methods—such as those based on cosine similarity—are challenging to formalize within the LLM context. To overcome this, the system relies on simple, text-based checks (e.g., keyword matching, exact pattern recognition, or text length constraints) or integrates external evaluation tools when needed.
The scientific novelty of this work lies in the following:
The first-ever formal definition of the class of “Reliability and Quality Control” primitives for no-code programming in the LLM environment, comprising “Supercycle,” “Control,” and “Result.”
An innovative self-correction mechanism for LLM outputs based on iterative execution and verification, which has no direct analogues in the existing prompt engineering literature.
The integration of reliable computing concepts into the no-code programming paradigm, enabling guaranteed result quality with a specified level of accuracy.
The most promising direction for applying the proposed primitives is the development of codeless agent systems. In such systems, agents built upon LLMs must execute complex, multi-step tasks with high reliability and autonomy. Reliability primitives will enable:
Creation of autonomous agents capable of verifying their own actions and correcting errors without external intervention.
Development of agents with guaranteed execution quality, which is critical for applications in finance, healthcare, or security.
Organization of agent-to-agent interaction, where one agent’s outputs are automatically verified by another before being passed on, ensuring data integrity throughout the system.
Implementation of a “reviewer agent” that employs the “Control” primitive to evaluate the performance quality of other agents.
Declaration on Generative AI During the preparation of this work, the authors used ChatGPT and Qwen to: execute the prompts provided in Section "4. Examples of Task Implementation," translate certain text fragments into English, perform grammar and spelling checks, and paraphrase or reword content. After using these tools, the authors carefully reviewed and edited the content as needed and take full responsibility for the publication’s content.