May 28, 2026
AI-Assisted Engineering:
The Agentic Workflow
A practitioner's guide to directing AI agents — from first prompt to shipped product. These principles were forged building a real-world, multi-agent application and apply to any domain.
Why This Matters
Large language models can generate code at extraordinary speed. But speed without direction produces fragile, unreliable software. The gap between a raw LLM and production-quality output is an engineering problem — and it requires an engineering solution.
The "Vibe Coding" Problem
When developers prompt an AI without structure — no requirements document, no plan review, no verification loop — they get what the industry calls "vibe coding." The output looks right but crumbles under real conditions: edge cases missed, schemas violated, security gaps introduced. At hobby scale this is tolerable. At production scale, it's a liability.
The Cost Lesson
My initial exploration began with cloud-hosted model APIs. Free tier rate limits proved restrictive, and the paid tier quickly accumulated a $400 API bill due to recursive multi-agent queries. This is a universal pattern: cloud inference costs scale unpredictably when agents call agents.
The Local Transition: To optimize costs, I transitioned to running local LLM models (Qwen, DeepSeek, Mistral) orchestrated via Ollama on a dedicated Dell enterprise server. This eliminated rate limits and billing overhead entirely — a strategy applicable to any heavyweight agentic project, not just biotech.
Google Antigravity IDE
An agent-centric variant of VS Code combining a standard code editor with an interactive Agent Manager to control concurrent autonomous coders in real time.
Ollama Local Model Suite
Self-hosted models running on dedicated server hardware, eliminating rate limits and billing overhead during continuous multi-agent debugging sessions.
Gemini CLI & Claude Code
Terminal-based agentic coding tools enabling headless, non-interactive batch processing and multi-step autonomous workflows.
The Document-Driven Development Framework
Autonomous programming requires strict human guidance and contract-driven verification. These three principles apply to any AI-assisted engineering project — from web applications to data pipelines to embedded systems.
1. Documents as Contracts
A structured Product Requirements Document (PRD) acts as a strict contract between the human engineer and the AI agent. It defines scope, architecture, constraints, and test scenarios in one canonical file.
The universal principle: If a requirement isn't written down, the agent won't build it correctly. This is true for biotech data pipelines, web apps, mobile apps, or any other domain. The PRD is the single source of truth.
2. Plan Approval Gates
Before any code is altered, the agent generates an Implementation Plan, Task Checklist, and Walkthrough. This plan requires manual review and explicit approval — a human-in-the-loop engineering checkpoint equivalent to a design review.
The universal principle: Code changes are never executed blindly. A human architect examines proposed diffs against security standards, schemas, and performance constraints before authorizing execution.
3. Verification & Model Switching
Features are tested recursively using automated suites. If errors persist after 2–3 attempts, the conversation thread is reset or the underlying LLM model is swapped entirely to break cognitive deadlocks.
The universal principle: LLMs have cognitive biases and context decay. When an agent loops on the same error, switching from (e.g.) Qwen to DeepSeek — or resetting context entirely — clears the loop. This is a general debugging technique, not domain-specific.
Case Study: The Biotech Analyzer
Here is how these principles played out on a real project — a multi-agent biotech intelligence platform that ingests SEC filings, clinical trial data, and market signals to produce structured investment analysis. Explore the live web-app and the industry research that underpins it.
Tier 1: Data Ingestion
Autonomous parsers and normalizers that ingest complex, unstructured sources — SEC HTML filings, PDF financials, and clinical registry data — extracting and cross-referencing key parameters into clean, queryable databases.
Tier 2: Analysis
Algorithmic assessors that evaluate pipeline gaps, perform scientific calculations, compare findings with historical benchmarks, and review code contributions module-by-module for style compliance and logic correctness.
Tier 3: Decision Synthesis
The intelligence layer. Compiles inputs from ingestion and analysis tiers to synthesize final, structured decisions — in this case, investment strategies and high-value recommendations backed by cross-agent consensus.
agent.py
The central execution script orchestrating 26 specialized agent classes across 3 functional tiers in concurrent, multi-threaded pipelines on local server hardware.
Lessons from v1 → v2
The Biotech Analyzer went through a full architectural rewrite. While the specifics are domain-specific, the underlying lessons are universal to any AI-assisted engineering project:
Modular architecture beats god classes.
The v1 database was a single monolith managing 40+ tables with raw SQL scattered everywhere. V2 introduced an ORM with strict data manager patterns, reducing tables to ~15 and making schema changes painless. In any project, keep agent logic decoupled from data access.
Pre-processing beats brute-force context.
Feeding entire 150k-token SEC filings into a prompt produced noisy, unfocused extractions. Structured pre-slicing (extracting only relevant sections first) reduced token volume by ~70% and dramatically improved recall. In any project, slice and filter data before passing it to an LLM.
Match model size to available hardware.
V1 attempted a 70B parameter model on 8GB VRAM — instant OOM errors. V2 right-sized: 8B for extraction, 3B for scoring, quantized 7B for synthesis, with staggered scheduling to prevent GPU contention. In any project, profile your hardware constraints before selecting models.
Operational Block Diagram
The interactive flowchart below illustrates the complete development loop — from initial idea through research, planning, coding, and verification. Click any node to explore its role.
Programmatic Workflow Engine
Click on any node in the diagram below to explore the core objectives and safeguards of each phase.
💡 Interactive Workflow Explorer
Click on any step of the programmatic block diagram above to explore the detailed mechanics, objectives, and vibration mitigations in Jonah's autonomous engineering workflow.
Conclusion & Future Outlook
The patterns documented here — documents as contracts, plan-before-code gates, verification loops with model switching — are not specific to biotech or any single domain. They are engineering fundamentals adapted for an era where AI agents are the primary code producers. Any team adopting agentic tools can apply this framework to eliminate "vibe coding" and build reliable, high-fidelity applications.
The paradigm of strict document-driven contracts and local model execution eliminates both uncontrolled AI output and excessive cloud resource bills. By building an operational bridge between research and software development, this workflow ensures that every codebase is grounded in empirical facts.
As the agentic ecosystem matures — with tools like Google Antigravity, Gemini CLI, and Claude Code becoming more capable — the competitive advantage will shift from having AI access to directing AI effectively. The engineers who treat AI agents as junior developers requiring clear specs, plan reviews, and test gates will consistently outperform those who treat them as magic boxes.