AI coding projects often become difficult at the point where observation turns into implementation. The market evidence points to the same underlying problem from several directions: multiple agents create coordination overhead, visual references mix facts with guesses, and automation becomes more reliable when a developer turns personal judgment into explicit rules. A useful response is an evidence-to-implementation brief: a review record that keeps observed facts, inferences, unresolved questions, and implementation suggestions separate before an AI coding assistant starts building.
What problem should builders solve first?
Builders should first reduce ambiguity in the handoff between evidence and code. The need is visible in the supplied examples: Shepi coordinates several AI coding agents across local and remote workspaces; rea-game separates what appears in gameplay footage from inferred rules and unanswered questions; and the web-perception project moved from unstable visual detection toward explicit, repeatable rules based on page structure.
The common signal is not simply that AI can generate more code. It is that operators now have more decisions to supervise. In Shepi's example, one agent may modify an interface while another checks tests and a server-side agent handles data. The operator must know who is working, who is waiting, and where intervention is required. The product described there uses status indicators, confirmation prompts, progress plans, diff inspection, and an inbox for missed events.
The evidence-to-implementation brief addresses the same coordination problem earlier in the workflow. Instead of asking an AI coding assistant to turn a loose description directly into a prototype, the operator records:
- **Observed facts:** what the source material directly shows.
- **Inferences:** what the reviewer believes may explain those facts.
- **Unresolved questions:** what cannot yet be confirmed.
- **Implementation suggestions:** possible prototype behavior, clearly marked as a proposal.
- **Evidence references:** timestamps, notes, screenshots, or other supplied identifiers where available.
This separation does not prove that a prototype is correct. It gives the operator a smaller, inspectable decision surface before implementation begins.
Why separate facts from implementation ideas?
Separating these categories prevents a plausible interpretation from being mistaken for a confirmed requirement. The rea-game project describes this distinction directly: a reviewer may record what happened in a game video, infer the underlying rule, and list what the footage cannot establish. The tool then generates a Markdown report and checks timestamps and format rather than pretending to understand the video automatically.
That boundary matters for AI coding. A generated interface can look coherent while still encoding an unsupported assumption. The supplied evidence also shows this problem in web automation. An early approach used YOLO annotations and training data, but fixed browser dimensions led to errors when the page changed. The project later shifted toward DOM information and explicit rules such as what counts as content, what counts as a control, when an action is permitted, and when the system should stop.
A brief can make those decisions visible before code exists. For example:
| Type | Example record | Review consequence | |---|---|---| | Observed fact | A control appears after a navigation step | The prototype may represent the sequence | | Inference | The control probably opens a detail view | Treat this as a hypothesis | | Unresolved question | The evidence does not show error behavior | Add a review task before implementation | | Suggestion | Model the sequence as a state transition | Allow the developer to accept or reject it |
The table is a proposed review format, not a reported market result. Its value is operational: the coding assistant receives a structured brief instead of an undifferentiated description.
How could the workbench be structured?
The workbench could be a hosted HTML app with a Python validation and generation layer, while SQLite retains review history. This maps directly to confirmed VicroCode capabilities: run HTML online can support the human inspection interface, run Python online can validate records and generate structured briefs, and the SQLite editor can support review-history storage and editing.
A practical first version needs four views:
- **Evidence intake:** create a project, add evidence records, and assign each record a category.
- **Review board:** inspect facts, inferences, unresolved questions, and suggestions in separate columns or tabs.
- **Validation report:** show missing evidence references, empty explanations, invalid categories, and suggestions that do not point back to an observation.
- **Brief output:** generate Markdown or structured text for an AI coding assistant and preserve the reviewed version in history.
The Python layer should apply deterministic checks before any model-assisted drafting. A record could require a category, a statement, a confidence note where appropriate, and an evidence reference when the claim depends on an external observation. The validator can reject a suggestion that has no linked fact or mark it for human review. It can also retain the original wording so later edits do not erase the difference between observation and interpretation.
SQLite is a reasonable fit for the first iteration because the evidence describes a review history rather than a large distributed data system. A compact schema might include `projects`, `evidence_items`, `review_decisions`, `brief_versions`, and `open_questions`. Each brief version should retain its creation time and source record identifiers. The exact schema is an implementation proposal, not a confirmed VicroCode feature beyond the stated SQLite and database-editing capabilities.
What should the AI coding assistant receive?
The assistant should receive the reviewed brief plus explicit boundaries, not raw evidence alone. A useful generated brief can contain five sections: confirmed observations, working hypotheses, unresolved questions, accepted implementation targets, and rejected or deferred ideas.
The implementation target should be phrased as a testable behavior. “The page should feel like the reference” is too vague. “Show a primary action after the user selects an item” is more concrete, but it still needs an evidence reference and a note about what remains unknown. The assistant can then create a small HTML prototype, use Python for supporting logic or validation, and store the review state in SQLite. Model Center APIs may be used for models already available through the platform when the operator wants help drafting or classifying a brief, but model output should remain a suggestion until a human accepts it.
This workflow also responds to the request for more predictable AI development. One market discussion asks how to choose a development base that reduces the feeling of a “black box.” The evidence does not establish that a particular framework solves that problem. It does show a demand for tighter constraints and clearer decisions. A structured brief is one way for an independent developer or small team to impose those constraints before code generation.
What should stay outside the first prototype?
Video extraction and automated visual understanding should stay outside the confirmed capability boundary and be marked **unverified**. The market example uses FFmpeg to extract frames and timestamped material, but that does not establish that VicroCode provides FFmpeg, video processing, or automated visual analysis. The review workbench can accept manually entered observations and references supplied by a reviewer; it should not claim to inspect video automatically.
The same caution applies to browser automation, remote servers, arbitrary frameworks, cloud databases, and deployment methods not listed among the confirmed capabilities. The workbench can use hosted HTML, online Python execution, Model Center APIs, API Endpoint Hosting and in-platform tool calls, file management, SQLite, LanceDB knowledge bases, and project publishing, hosting, sharing, or monetization. A requirement outside that set should be labeled **unverified** or described as an external dependency requiring separate confirmation.
LanceDB could become useful when a project has many prior briefs and the operator wants to retrieve related observations or unresolved questions. That is a possible extension, not a claim that a knowledge base automatically improves prototype quality. Similarly, API Endpoint Hosting could expose a controlled brief-generation endpoint, but the endpoint contract, authentication model, and production capacity are unverified from the supplied evidence.
How should a small team test the workflow?
A small team should test whether the brief makes decisions easier to inspect, not whether it creates impressive output. Start with one narrow reference set and record a limited number of observations. For each proposed feature, require a link back to at least one observation and identify any behavior that remains unknown.
The team can then compare two paths: direct prompting and brief-first implementation. The supplied evidence does not provide a validated benchmark for this comparison, so any measured improvement would be unverified until tested. Useful review questions include:
- Can another developer distinguish fact from inference without asking the original reviewer?
- Are unresolved questions visible before implementation begins?
- Can the assistant produce a prototype without silently converting a suggestion into a requirement?
- Can the team recover an earlier brief version from SQLite?
- Can a reviewer inspect the HTML result and the source decisions in one hosted workspace?
The result is not a promise of faster delivery or higher accuracy. It is a reproducible review loop: collect evidence, classify it, validate the record, decide what is safe to implement, generate a brief, inspect the prototype, and update the open questions.
What does this mean for AI project operators?
The practical shift is from asking an agent to produce an answer toward giving it a reviewed set of decisions. Shepi's design makes agent state, intervention, progress, and output visible during implementation. The evidence-to-implementation workbench applies the same operational discipline before implementation: it makes the source of a decision visible and leaves uncertainty in the record.
For an independent developer, the first deliverable is small enough to build with confirmed capabilities: an HTML review interface, Python validation and brief generation, SQLite history, and optional model assistance through available Model Center APIs. The boundary is equally important. Automated video extraction and visual understanding remain **unverified**; the human reviewer still supplies the observations.
That is a useful product shape because it does not pretend that ambiguity has disappeared. It gives the developer a place to put ambiguity, test assumptions, and decide what an AI coding assistant is actually allowed to build.
FAQ
Is this workbench a video-analysis tool?
No. Video extraction and automated visual understanding are **unverified** within the confirmed capabilities. The workbench can organize manually supplied observations and evidence references.
Which VicroCode capabilities fit the prototype?
The confirmed fit is a hosted HTML app, online Python execution, SQLite storage and editing, optional Model Center APIs, file management, and project publishing or sharing. Other languages, frameworks, cloud services, and deployment methods are **unverified**.