DEV Community: Keo Fung | FormLM

[2/10]Designing a YAML-Based Task Planning System for AI-Driven Application Generation

Keo Fung | FormLM — Mon, 06 Jul 2026 06:38:24 +0000

Series: Building a Modular Assessment Engine (2/10)

The plan agent's job sounds simple: read a user's request, decide which modules to run, output a task list. In practice, this was the hardest component to get right. One wrong decision in planning cascades through every downstream module.

The Strategy Decision Matrix

The core of the plan agent is a decision matrix — a table that maps user intent to a module sequence. I tried free-form AI planning first. It was a disaster. The AI would invent modules that didn't exist, skip required ones, or order them wrong.

The matrix constrains the AI to six plan types, each with a fixed module sequence:

planType	Module Sequence	When to Use
`consultation`	form→scale→connect→report→expert→share	Assessment + AI expert follow-up
`assessment`	form→scale→connect→report→share	Self-assessment with PDF report
`report`	form→scale→connect→report→share	External evaluation/rating
`exam`	form→scale→connect→report→share	Knowledge test with correct answers
`survey`	form→connect→share	Data collection, no scoring
`learn`	form→connect→share	Flashcard learning with quick quizzes

The rule is strict: the AI cannot generate modules outside this table. If the user asks for something that doesn't fit any row, the AI picks the closest match. No free-form module creation.

The YAML Output Contract

The plan agent outputs pure YAML, wrapped in code fences:

planType: assessment
description: 'Workplace Stress Assessment'
tasks:
  - seq: 1
    skill: form
    title: 'Design Assessment Form'
    description: 'Create 3-dimension stress assessment with 13 questions'
    knowledge: |
      Scene: assessment. Name field: "Your Name".
      3 dimensions:
      - Workload (5 questions, measures perceived work intensity)
      - Role Stress (4 questions, measures role ambiguity and conflict)
      - Social Support (4 questions, measures workplace support networks)
      Total: 13 questions. Use scale type (1-5 Likert).
  - seq: 2
    skill: scale
    title: 'Configure Scoring'
    knowledge: |
      3 dimensions, all negative direction (high score = worse).
      Workload: 5 questions, sum format.
      Role Stress: 4 questions, sum format.
      Social Support: 4 questions, sum format.
      3-tier ranges per dimension (severe/moderate/mild).
  - seq: 3
    skill: connect
    lookAndFeel: 'theme:Noir; look:workplace stress, psychological assessment, dark professional; layout:stack'
    title: 'Configure Pages and Style'
    knowledge: |
      Cover: hook with 73% statistic, 5-minute estimate, dimension preview.
      Main: field mode (one question per page).
      Final: report-pdf with download enabled.
  - seq: 4
    skill: report
    lookAndFeel: 'theme:Noir; look:dark professional, consistent with connect'
    knowledge: |
      3 dimensions, theme:Noir. Radar chart for summary.
      Per-dimension: high/mid/low 3-tier interpretation.
      Total score: low=good, high=needs support (symptom scale).
  - seq: 5
    skill: share
    title: 'Publish'
    knowledge: |
      Anonymous access, one submission per person, permanent validity.

The Knowledge Self-Containment Rule

This is the most important rule in the entire system, and it took three iterations to enforce:

Each task's knowledge field is the ONLY context that skill receives.

Task 1 (form) knows nothing about Task 2 (scale). Task 2 knows nothing about Task 3 (connect). When the scale skill runs, it doesn't see what the form skill generated — it only sees its own knowledge field plus runtime references (the actual form fields that now exist in the database).

Why? Because the execution engine runs each task as an independent AI call. There's no conversation history between tasks. This was a deliberate design choice for reliability — if Task 3 fails, Task 4 can still run because it doesn't depend on Task 3's chat history.

But it means the plan agent must be explicit. If the form task says "3 dimensions: Workload, Role Stress, Social Support," the scale task must repeat those exact names. The connect task must mention them for the cover page preview. The report task must list them for interpretation.

The Strong Consistency Rule

The plan agent enforces verbatim name consistency across tasks. If the form task calls a dimension "Workload," the scale task cannot call it "Workload Intensity." The names must match character-for-character because downstream modules do string comparison.

// In the execution engine, scale dimension names are matched against
// form field groupings by exact string comparison
for (Scale scale : factor.getScales()) {
    String scaleName = scale.getName();
    // This must EXACTLY match the dimension name in the form task's knowledge
    if (!formKnowledge.contains(scaleName)) {
        FLog.w(TAG, "Scale name mismatch: " + scaleName);
    }
}

What Went Wrong: The "Same As Above" Problem

Version 1 of the plan agent didn't enforce self-containment. The AI, being efficient, would write:

# Task 1
- skill: form
  knowledge: |
    3 dimensions: Workload, Role Stress, Social Support.
    13 questions total.

# Task 2 — the AI got lazy
- skill: scale
  knowledge: |
    Same 3 dimensions as above. Sum format, 3-tier ranges.

"Same 3 dimensions as above" — except there is no "above" when the scale skill runs. It's a fresh AI call with only this knowledge block. The scale skill would generate 3 empty dimensions named "Dimension 1," "Dimension 2," "Dimension 3" because it had no idea what the actual dimension names were.

What Went Wrong: Phantom Modules

Version 2 introduced a different problem. The AI would sometimes add a feedback or analytics module that doesn't exist:

tasks:
  - skill: form
  - skill: scale
  - skill: connect
  - skill: report
  - skill: analytics   # ← doesn't exist
  - skill: share

The execution engine would crash trying to load skills/assess/skill-analytics/SKILL.md.

The fix: the available skills are now dynamically injected into the plan agent's system prompt at runtime:

StringBuilder skillsSection = new StringBuilder();
skillsSection.append("## Available Skills\n\n");
skillsSection.append("Each task's `skill` field MUST be selected from this list:\n\n");
for (String skillId : BUILDER_SKILL_IDS) {
    AssessPlanSkill skill = getOrCacheSkill("skills/assess/skill-" + skillId + "/SKILL.md");
    skillsSection.append("- `").append(skillId).append("`: ").append(skill.getSummary()).append("\n");
}
String systemPrompt = agentContent + skillsSection;

The AI sees the exact list of available skills in its system prompt. No more phantom modules.

What Went Wrong: PageTemplates Leakage

The plan agent used to output a pageTemplates field in report tasks — a list of template IDs for the report module. This was fragile because the AI would sometimes output invalid template names, or forget to include them entirely.

The current solution: the plan agent never outputs pageTemplates. Instead, it declares two values in the report task's knowledge:

DimN=3
theme=Noir

The execution engine reads these values and computes the page template list automatically:

// In AssessAgent.skillGenerateStream()
if ("report".equals(skillName) && ObjectUtil.isEmpty(task.getPageTemplates())) {
    // Recover from scale data — count actual dimensions in memory
    Factor _factor = session.getFlower().getModel().getFactor();
    if (_factor != null && !ObjectUtil.isEmpty(_factor.getScales())) {
        int _dimCount = _factor.getScales().size();
        List<String> _recovered = buildPageTemplates(_dimCount, task, planType);
        task.setPageTemplates(_recovered);
        FLog.w(TAG, "pageTemplates recovered from scale data, dimCount=" + _dimCount);
    }
}

This is a runtime fallback: even if the plan agent messes up, the execution engine can reconstruct the page template list from the actual scale dimensions in memory. The AI doesn't need to know about template IDs at all.

The LookAndFeel Field

Three tasks can carry a lookAndFeel field: connect, report, and expert. This is a semicolon-delimited string:

theme:Noir; look:workplace stress assessment, dark professional, deep blue; layout:stack

The plan agent generates this once, and downstream skills extract values from it:

theme: → presets the visual theme (Noir, Classic, Fresh, etc.)
look: → natural language visual description for the style AI
layout: → page flow type (flat, stack, cube)

The rule: if a task has lookAndFeel, downstream skills must use it. If the connect task says theme:Noir, the report task cannot override it with theme:Fresh. The plan agent enforces this by generating consistent lookAndFeel values across connect/report/expert tasks.

Lessons Learned

Constrain the AI. Free-form planning sounds flexible but produces garbage. A decision matrix with 6 rows covers 95% of use cases and eliminates phantom modules.
Self-containment is non-negotiable. Cross-task references break when tasks execute independently. Validate and reject them early.
Don't trust the AI with internal IDs. Template names, page IDs, and other internal identifiers should be computed by the engine, not generated by the AI.
Always have a runtime fallback. If the plan agent forgets to declare dimension count, the execution engine should be able to count them from the in-memory scale data.

Next: [Form Module — Scene-aware field types and inline scoring]

[1/10] How I Built an AI-Powered Assessment-to-Report Pipeline with 6 Modular Skills

Keo Fung | FormLM — Mon, 06 Jul 2026 04:23:29 +0000

Series: Building a Modular Assessment Engine (1/10)

What if a user could type one sentence — "build a workplace stress assessment" — and get a complete, publishable assessment application with a scoring engine, a styled UI, a personalized PDF report, and an AI expert assistant?

That's what I spent the last year building. This series breaks down the architecture, module by module, including the bugs that nearly killed it.

The One-Sentence Input Problem

The core challenge: turn natural language into a fully functional application. Not a template. Not a wizard. An actual app with form fields, scoring logic, visual design, and a PDF report — all generated, all working.

The solution I landed on is a modular skill pipeline. Six independent modules, each with its own AI prompt specification (SKILL.md), each generating CLI commands that mutate a shared domain model. A planning agent decides which modules to activate and in what order.

The Six Modules

User Input → [Plan Agent] → Task Sequence → Execution Engine → Published App

Modules:
  1. form    — Form field design (question types, scoring, grouping)
  2. scale   — Dimension scoring (factors, ranges, direction handling)
  3. connect — UI pages (cover, main form, final page, visual style)
  4. report  — PDF report (page templates, widgets, score logic)
  5. expert  — AI assistant (role, welcome message, behavior boundaries)
  6. share   — Publishing (access control, permissions, validity)

Each module has:

A SKILL.md file that serves as the AI's system prompt (commands, rules, examples)
A CLI command set for mutating the domain model
References — runtime data the AI reads before generating commands (current form fields, scale dimensions, report pages, etc.)

The AI doesn't write code. It writes CLI commands. The execution engine runs them against the domain model.

The Plan Agent

The plan agent is the brain. It takes user input and outputs a YAML task list:

planType: assessment
description: 'Workplace Stress Assessment'
tasks:
  - seq: 1
    skill: form
    title: 'Design assessment form'
    knowledge: |
      Scene: assessment. 3 dimensions: Workload (5 questions),
      Role Stress (4 questions), Social Support (4 questions).
  - seq: 2
    skill: scale
    title: 'Configure scoring dimensions'
    knowledge: |
      3 dimensions, all negative direction (high score = worse).
      3-tier ranges per dimension.
  # ... connect, report, share follow

The knowledge field is critical: it's the only context each skill receives during execution. Task A's knowledge doesn't leak into Task B. This forces each knowledge block to be self-contained — dimensions, question counts, scoring rules, everything.

This was a hard lesson. Early versions had tasks referencing "same as above" or "see form task." The execution engine runs tasks independently, so those references resolved to nothing. Half the generated apps were broken.

The Execution Engine

Execution is SSE-streamed. For each task:

Load the skill's SKILL.md as system prompt
Inject the task's knowledge + runtime references (current app state)
Start an SSE stream to the AI model
Each line the AI generates is a CLI command — execute it immediately
Feed the result back to the execution context

Task: form
  AI generates:  assess form add --id name --type input --title "Your Name"
  Engine:        → executes, field created
  AI generates:  assess form add --id workload_1 --type scale --min 1 --max 5 ...
  Engine:        → executes, field created
  ...
Task: scale
  AI generates:  assess scale add --id workload --name "Workload" --format sum ...
  Engine:        → executes, dimension created
  ...

The streaming approach means commands execute as they're generated, not after the full response. This cut generation time by ~40% for typical apps.

The Domain Model

Underneath, there's a Java domain model with a builder pattern:

Flower (root)
  └── Model
       ├── Factor
       │    └── Scale[] (dimensions)
       │         └── Data[] (score ranges)
       ├── Form (fields)
       │    └── Field[]
       ├── Connect (pages)
       │    ├── CoverPage[]
       │    ├── MainPage
       │    └── FinalPage[]
       ├── Report (pages)
       │    └── ReportPage[]
       │         └── Widget[]
       └── Expert (AI assistant config)

Each CLI command mutates this tree. The SessionContext holds the in-memory state during execution, then persists everything in one batch at the end. This avoids N separate database writes during a 50-command form task.

The Two Agents

There are actually two AI agents in the system:

AssessAgent — the one-shot generator. Takes user input → plans → executes → done. Used when creating a new app from scratch. Two phases: plan() and execute().

BuilderAgent — the conversational editor. Used when modifying an existing app. Four phases: Think (analyze current state) → Plan (generate PATCH tasks) → Execute (stream commands) → Reflect (AI verifies results and responds to user).

Same skill SKILL.md files power both agents. The difference is context: AssessAgent starts from empty, BuilderAgent starts from a snapshot of the existing app.

What's Next

This series will deep-dive each module and the infrastructure around them:

[This post] Architecture overview
The Planning Engine: YAML task routing and knowledge self-containment
Form Module: Scene-aware field types and inline scoring
Scale Module: Solving the dimension direction problem
Connect Module: AI-driven cover pages and visual styles
Report Module: Page-templated PDF generation
Expert Module: Giving AI assistants personality and boundaries
The One-Click Pipeline: How one SSE stream orchestrates everything
SSE Reliability: Three rounds of fixing event loss
PDF Rendering War: SVG, emoji, and the iText NPE

Each post includes real code, real bugs, and the solutions that survived production.

This series documents the architecture of an assessment platform. I'm sharing the engineering decisions and failures — not pitching a product. If you're building something similar (AI-driven code generation, modular skill systems, PDF rendering pipelines), hopefully this saves you some pain.

How I Built an AI Assessment Tool to Productize My Consulting Expertise (Without Coding)

Keo Fung | FormLM — Mon, 25 May 2026 10:30:53 +0000

If you're a consultant, coach, or domain expert, you know the drill: your income is strictly tied to your hours. You can only take on so many clients, and scaling means hiring more people, which dilutes your margins and your unique value.

I hit this exact ceiling a few months ago. I had a proven diagnostic framework that worked wonders for my clients, but I was manually running every single assessment. It was exhausting. I needed a way to productize my knowledge—to turn my brain into a scalable asset that could generate leads and deliver value 24/7.

The problem? I'm not a developer. Building a custom web app to handle complex conditional logic and generate personalized PDF reports was going to cost thousands of dollars and take months.

That's when I discovered a no-code approach using AI.

The "Time-for-Money" Trap

Before we dive into the solution, let's look at why traditional consulting is so hard to scale:

1.The Lead Gen Struggle: Giving away static PDFs or whitepapers doesn't work anymore. People want immediate, personalized insights.

2.The "Prove It" Problem: It's hard to demonstrate the value of your expertise before a client signs the contract.

3.The Delivery Bottleneck: Even if you get 100 leads, you can't manually assess all of them.

I needed a "hook" that was highly engaging, automated, and actually useful to the user. An interactive assessment was the perfect answer.

The Solution: AI-Powered Forms

I started looking for form builders, but standard tools like Typeform or Google Forms were too rigid. They couldn't handle the nuanced scoring logic my framework required, and they definitely couldn't generate a personalized, multi-page report at the end.

I eventually found FormLM, a platform specifically built for this exact use case. It's an AI Form Builder designed to turn professional knowledge into automated assessment services.

Here is how I set it up:

Step 1: Digitizing the Framework

Instead of writing complex if/then statements, I used FormLM's AI builder to input my diagnostic criteria. The AI helped structure the questions to ensure they flowed logically and captured the right data points.

Step 2: Designing the Personalized Report

This is where the magic happens. FormLM takes the user's inputs and uses AI to generate a highly personalized assessment report. It doesn't just say "You scored a 7/10." It provides specific, contextual feedback based on my methodology.

Step 3: The AI Consulting Assistant

I also enabled their AI Consulting feature. Now, after a user gets their report, they can chat with an AI assistant that is trained exclusively on my knowledge base. It answers follow-up questions and naturally guides them toward booking a paid consultation with me.

The Results

The impact on my business was immediate:

•Lead Quality Skyrocketed: Instead of generic email captures, I now get detailed profiles of my prospects before we even speak.

•Instant Trust: Because the automated report delivers real value, prospects enter the sales call already trusting my expertise.

•True Scalability: My framework is now assessing dozens of companies a week while I sleep.

How You Can Do It Too

If you have a proven methodology—whether it's an "Enterprise Digital Maturity" diagnostic, a "Marketing ROI Calculator," or an HR "Culture Fit" assessment—you are sitting on a goldmine.

You don't need to learn React or hire an agency to build a SaaS. You just need to translate your logic into an automated workflow.

If you want to break free from the billable-hour trap, I highly recommend checking out FormLM. It’s the fastest way I've found to turn your expertise into a 24/7 product.

FormLM

Keo Fung | FormLM — Sun, 24 May 2026 09:44:28 +0000

FormLM is the assessment platform built for people who sell expertise — consultants, coaches, trainers, and advisors who know their craft inside out but are tired of delivering the same insights one hour at a time.

What you actually get done

Create evaluation scales, application forms, and self-assessment modules in one place. Respondents fill them out; FormLM handles the data collection, runs the analysis, and produces a finished report. Whether it's a business health check, a competency review, a qualification application, or a client diagnostic — you build the form once, and it runs itself from there.

How it works

The pipeline is Form → Scale → Connect → Report → Expert. Design a smart form, attach your professional scoring model, connect data across channels, auto-generate assessment reports, and layer in expert logic for follow-up guidance. Every step lives in the same system — no jumping between tools, no copy-pasting results into a Word doc at midnight.

Why people switch

Building an evaluation scale or a formal assessment application used to mean days of setup and a pile of manual work. With FormLM, you go from idea to a fully functional assessment in minutes. Less time producing deliverables, more time doing work that actually requires you. Your expertise stops being a bottleneck and starts being a product.