Audit & Stabilize
Add evals, observability, and regression testing. Ship confidence, not just code.
Week 1: Eval dashboard that fails the build if hallucinations >5%.
RAG pipelines · Agent systems · Evaluation frameworks · Production deployment
Your RAG pipeline works in the notebook. In production?
15%+ citation errors on real queries
4s+ p95, users bouncing
Every release = manual QA, crossed fingers
$0.02/query in dev, $0.40 in prod
What worked Tuesday fails Friday
"Why did it answer that?" → 🤷
You’ve hit the wall. I’ve climbed it.
I’ve debugged RetrievalQA at 2am. Watched a demo crash 5 minutes before an investor call. I know the gap — and I know how to close it.
Here’s what that looks like when it’s fixed.
Deep-dives with architecture, metrics, and code.
RAG over 500k legal documents
Founding AI Engineer (sole)
Prototype hallucinated 18% of citations; 4.2s p95 latency; zero automated eval
Built hybrid retrieval (BM25 + dense + reranker), custom eval suite (RAGAS + 12 domain metrics), streaming responses, prompt versioning, cost tracking
from ragas import evaluatefrom ragas.metrics import faithfulness, answer_relevancy # Custom domain metricsclass CitationAccuracy: def __call__(self, row): citations = extract_citations(row.answer) verified = verify_against_source(citations, row.contexts) return len(verified) / len(citations) if citations else 1.0 eval_dataset = load_dataset("legal-qa")results = evaluate( eval_dataset, metrics=[faithfulness, answer_relevancy, CitationAccuracy()],) # CI gate: fail if hallucinations > 5%assert results['CitationAccuracy'] > 0.95Multi-agent financial research system
Lead AI Engineer (2-person team)
Agents looped infinitely; tool calling unreliable; no observability
Structured agent framework with Temporal orchestration, custom tool retry logic, Langfuse tracing, human-in-the-loop checkpoints
from temporalio import workflowfrom langgraph.graph import StateGraph class ResearchWorkflow: @workflow.run async def run(self, query: str) -> Report: # Structured agent with checkpoints planner = create_planner_agent() researcher = create_researcher_agent() writer = create_writer_agent() plan = await planner.aplan(query) findings = await researcher.aresearch(plan) report = await writer.awrite(findings) # Human-in-the-loop for compliance if report.risk_level == "high": report = await workflow.wait_for_human_review(report) return reportInternal tooling for AI team
Sole builder
5 engineers, 0 shared eval infrastructure; every team reinventing metrics
Centralized eval platform — dataset management, prompt A/B testing, regression detection, cost/latency dashboards, CI/CD integration
@app.post("/eval/run")async def run_evaluation(request: EvalRequest): dataset = load_dataset(request.dataset_id) results = [] for sample in dataset: output = await run_pipeline(sample.input, request.prompt_version) metrics = compute_metrics(sample.expected, output) results.append({**sample.dict(), **metrics, "output": output}) # Regression detection baseline = get_baseline(request.prompt_version) regressions = detect_regressions(results, baseline) await store_results(request.run_id, results, regressions) return {"run_id": request.run_id, "regressions": regressions}Three steps. No handoffs. Production from day one.
Add evals, observability, and regression testing. Ship confidence, not just code.
Week 1: Eval dashboard that fails the build if hallucinations >5%.
Fix retrieval, add streaming and guardrails. Turn "sometimes works" into "always works."
Prompt versioning, cost dashboards, runbooks. Enable the next hire from day one.
Eval before code — No feature merges without an eval that would catch its failure
Observability is not optional — Traces, metrics, logs from the first deploy
Cost is a feature — Token budgets, caching, model routing built in, not bolted on
Guardrails > hope — Output validation, fallback chains, human-in-the-loop where it matters
Document decisions, not just code — ADRs for architecture, prompt versioning, runbooks for on-call
Ship to learn — Real user feedback > perfect benchmarks
I choose boring, proven infrastructure (PostgreSQL, Redis, Kubernetes) so the interesting complexity lives in the LLM layer — where it creates value.
Peer-reviewed AI research. MSc Computer Science (In View), Artificial Intelligence, MAU Yola.
Manunyi Godfrey & Dahiru Haruna Usman
Introduces "explainability fatigue": the point where high-volume XAI explanations overwhelm users, drive disengagement, and erode trust. Makes the case for context-aware, cognitively sustainable transparency.
Manunyi Godfrey, Shaphat Safethon & Kayode Oladipupo Oluborode
A formal methodology for structurally validating and evaluating the ontologies behind education-domain knowledge graphs: measurable quality for semantic data in learning systems.
Specific results. Real testimonials. Open source.
Solana SPL Metadata program to update token metadata credentials
Manunyi took our RAG system from 'works in dev' to 'we trust it in prod.' The eval framework he built caught a regression that would have cost us a major customer. Rare combination of ML depth and shipping speed.
I've worked with many ML engineers. Manunyi is one of the few who thinks like a product engineer — he understands the business constraint, not just the model metric.
Placeholder testimonials — replace with real ones before launch.
retrieval, callbacks
eval metrics for citation faithfulness
"Building Eval-First LLM Systems"
8k views
"From Notebook to Production: An LLM Engineer's Checklist"
Conference talk
I’m currently open to full-time AI Engineer roles (founding engineer / senior IC) at AI-first startups.
Available immediately • Open to remote / hybrid / relocation
Accepting conversations for Q1 2027. Response time: usually within 24 hours.