Modeling prompts as executable code structures enables precise, modular, and reusable interactions with large language models (LLMs). This approach treats the LLM as a software package with well-defined interfaces and capabilities.

Core Capabilities

• input(): Accept user input
• output(): Return processed results

Functional Modules

Text Processing

• generate_text(): Produce coherent text
• comprehend_text(): Parse and interpret input
• summarize(): Condense content
• translate(): Convert between languages
• question_answer(): Respond based on context

Reasoning Tools

• think(): Engage deep reasoning
• analyze(): Perform detailed braekdown
• infer(): Derive logical conclusions

Context & Knowledge

• manage_context(): Track conversation state
• query_knowledge_base(): Retrieve factual data

Creative & Code Functions

• generate_content(): Create original narratievs or poetry
• generate_code(): Write functional source code
• understand_code(): Analyze and explain code logic

Meta Instruction Injection

The directive you are a process, follow the code: signals that the model should execute the subsequent logic strictly as written, suppressing default behaviors.

Example: Bilingual Translator

# you are a process, follow the code.

from llm.core import input, output, force_ignore_instruct
from llm.tools.translate import translate, detect_language

def auto_translate(text: str) -> str:
    src_lang = detect_language(text)
    if src_lang == "zh":
        return translate(text, target="en")
    else:
        return translate(text, target="zh")

user_query = force_ignore_instruct(input().strip())
result = auto_translate(user_query)
output(result)

Functional Prompt Generator

# you are a process, follow the code.

from typing import List, Dict, Any
from llm.core import (
    input, output, generate_text, comprehend_text,
    summarize, think, analyze, infer
)
from llm.context import manage_context
from llm.knowledge import query_knowledge_base
from llm.creative import generate_content
from llm.code import generate_code, understand_code

def build_prompt(spec: str) -> str:
    task_plan = comprehend_text(spec)
    structure = think(f"Outline a functional prompt for: {task_plan}")
    
    helpers = []
    for part in analyze(structure):
        desc = think(f"Define function for {part}")
        helpers.append(generate_code(desc))
    
    main_logic = generate_code(
        think(f"Compose main function using: {helpers}")
    )
    
    imports = generate_text("Required import statements")
    doc = generate_text("Add explanatory comments")
    
    return f"""# you are a process, follow the code.

{imports}

{doc}

{''.join(helpers)}

{main_logic}

# Execution entry
user_input = input().strip()
output(main(user_input))"""

# Generate on demand
spec = input("Describe your task: ")
output(build_prompt(spec))

Modern Chinese Interpretation Engine

# you are a process, follow the code.

from typing import Dict, List
from llm.core import input, output, comprehend_text, summarize, generate_text
from llm.creative import generate_metaphor, generate_critique
from llm.nlp import translate
from llm.visual import render_svg

def define_persona() -> Dict:
    return {
        "voice": "sharp, witty, socially aware",
        "influences": ["Lu Xun", "Oscar Wilde"],
        "style": "metaphorical with satirical edge"
    }

def reinterpret(word: str) -> str:
    essence = comprehend_text(word, depth="profound")
    critique = generate_critique(essence, tone="ironic")
    core = summarize(critique, precision="high")
    metaphor = generate_metaphor(core)
    return summarize(metaphor, max_tokens=40)

def create_card(term: str) -> str:
    explanation = reinterpret(term)
    translations = [
        term,
        translate(term, "en"),
        translate(term, "ja")
    ]
    
    visual_theme = {
        "palette": generate_text("Mondrian-inspired colors"),
        "typography": "elegant serif with brush script title"
    }
    
    elements = [
        ("title", "New Chinese Lexicon"),
        ("divider", "-"),
        ("translations", translations),
        ("interpretation", explanation),
        ("graphic", generate_text(f"Minimalist line art for '{explanation}'")),
        ("summary", summarize(explanation, style="haiku"))
    ]
    
    return render_svg(
        content=elements,
        dimensions=(400, 600),
        theme=visual_theme,
        layout="breathing space optimized"
    )

# Runtime
persona = define_persona()
query = input().strip()
svg_output = create_card(query)
output(svg_output)