AI Skill Report Card

Building Multi Language Autofix Agent

C+62·Nov 19, 2026·Source: Extension-page
12 / 15

Before writing any code, read the existing project memory/skill file (e.g. autofix-jh.md) to recover prior architecture decisions. Never restart from scratch unless explicitly told to. Build incrementally in large chunks delivered as a single document the user can open, with clear part boundaries (Part 1: core server + UI, Part 2: scanner, Part 3: fixer, Part 4: pipeline).

Python
# Minimal skeleton for Part 1 (local Flask/FastAPI server + web UI) app = Flask(__name__) @app.route("/") def index(): return render_template("index.html") # project picker, scan button, settings tab, chat tab @app.route("/api/settings", methods=["POST"]) def save_settings(): # store API keys (Gemini/Anthropic/OpenRouter) in local encrypted config, never hardcode ... @app.route("/api/scan", methods=["POST"]) def scan_project(): # walk project tree top-to-bottom, detect language per file/folder, detect build configs ...
Recommendation▾
This is overly specific to one project (AUTOFIX JH) rather than a generalizable skill — consider abstracting the methodology so it transfers beyond this single app
12 / 15

Progress:

  • Step 0: Read prior memory doc / skill file for this project before writing anything
  • Step 1: Confirm architecture decision — modify existing version vs. new clean build (ask once, not repeatedly)
  • Step 2: Build core server + web UI shell (project selector, auto-scan trigger, settings page for API keys, chat panel with the model)
  • Step 3: Build the Scanner/Understanding module — walks all folders root-to-leaf, detects language (support 20+ languages across desktop/mobile/web), detects configs, build files, and inter-file links/dependencies
  • Step 4: Build the Error Detection module — runs local linters/compilers per language if available, falls back to LLM-based static analysis if tool is missing
  • Step 5: Build the Fix Suggestion module — generates proposed diffs, never silently overwrites without a clear fix record
  • Step 6: Build the Auto-Fix Execution module — applies fixes folder-by-folder in deterministic order, logs every change
  • Step 7: Wire the Pipeline — single button runs Scan → Detect → Suggest → Fix end-to-end across whole project
  • Step 8: Connect LLM backend — user's own API key(s) entered via Settings UI only; agent never manages external runtime (e.g. Colab) — agent just calls the API endpoint the user configures
  • Step 9: Deliver as one complete, runnable document/file set; keep iterating in parts on user request
Recommendation▾
Description is borderline project-documentation rather than a reusable skill description; tighten the trigger clause to clarify when Claude should invoke this versus just building a normal app
11 / 20

Example 1: Input: User says "ابدأ بالمشروع" (start the project) after confirming scope. Output: Deliver Part 1 immediately — full working server + UI code (settings page with API key fields for Gemini/Anthropic/OpenRouter, project folder picker, auto-scan trigger, chat-with-model panel) — as one complete file, no placeholders, no "TODO: implement this."

Example 2: Input: User mentions running the model on Google Colab with their own keys. Output: Treat Colab purely as the user's chosen runtime for the model backend. The agent/app only needs a configurable API endpoint + key field in Settings. Do not generate Colab notebook instructions unless explicitly asked — stay inside the project/app itself.

Recommendation▾
Examples are narrow (only two, both project-specific with non-English input) — add a concrete before/after code diff example showing the fix-suggestion workflow in action
  • Always re-read the project's memory/skill document first; treat it as source of truth over chat history.
  • Keep secrets (API keys) only in local settings storage entered through the UI — never hardcode or ask the user to paste them into chat.
  • Default to covering 20 languages across three platforms (desktop, mobile, web) — e.g. Python, Node/JS/TS, Java, Kotlin, Swift, C/C++, C#, Go, Rust, PHP, Ruby, Dart/Flutter, HTML/CSS, SQL, Shell, etc. Use local toolchain (linters/compilers) when present, fall back gracefully when absent.
  • Process folders in a stable top-to-bottom order and log every fix made for traceability/rollback.
  • Ask clarifying questions only once, before starting, not repeatedly mid-build.
  • Deliver real, complete, runnable code per part — not stubs or partial snippets.
  • Don't silently assume the user wants a brand-new rebuild — always check for an existing version first.
  • Don't conflate "runtime the user picked" (e.g. Colab) with "what the agent must manage" — the agent only needs a configurable endpoint/key.
  • Don't apply fixes without a visible suggestion/record step — full blind auto-overwrite breaks trust.
  • Don't skip languages/platforms silently; if a local tool is missing, explicitly fall back instead of failing quietly.
  • Don't re-ask architecture questions the user already answered in-session.
0
Grade C+AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
12/15
Workflow
12/15
Examples
11/20
Completeness
14/20
Format
11/15
Conciseness
12/15