DEV Community: abdul rahman

AutoFix & Compatibility Agent – AI Advisor on Sanity Structured Data

abdul rahman — Sat, 19 Sep 2026 22:35:29 +0000

What I Built

AutoFix Knowledge Agent is an intelligent automotive diagnostics and spare parts compatibility advisor powered by Sanity's Structured Content Lake and high-speed LLM reasoning.

In automotive maintenance, a simple keyword search or hallucinated AI response can lead to expensive or hazardous errors (e.g., purchasing a spark plug with the wrong thread pitch, electrode gap, or heat rating for a modern engine).

This agent solves this by using Sanity as the single source of truth, establishing relational integrity between vehicle models, spare parts, and OBD-II diagnostic troubleshooting guides.

Submission Details & Mandatory Identifiers 📌

Sanity Project ID: tftsdpi3
Dataset: production
Public Dataset URL: https://tftsdpi3.api.sanity.io/v2024-03-01/data/query/production?query=*[_type in ["vehicle","part","troubleshoot"]]
Live Demo: https://sanity-autofix-agent.vercel.app
Source Code (GitHub): https://github.com/abdulrahman-maslmany/sanity-autofix-agent

Why Structured Content Was Crucial

Traditional RAG systems that rely solely on flat, chunked vector search struggle with negative constraints and multi-hop compatibility logic.

With Sanity's TypeScript schemas, we structured:

Vehicles: name, make, year, engineType.
Spare Parts: partNumber, title, specifications, and explicit Reference Arrays (compatibleVehicles[]->name).
Troubleshooting Guides: errorCode (e.g. P0300), symptoms, solutions, and related replacement parts.

When a user asks: "Is SK16R11 compatible with Toyota Camry 2023?", the agent queries the relational graph via GROQ:


groq
{
  "vehicles": *[_type == "vehicle"]{ name, make, year, engineType },
  "parts": *[_type == "part"]{ 
    partNumber, 
    title, 
    specifications, 
    "compatibleVehicles": compatibleVehicles[]->name 
  },
  "troubleshooting": *[_type == "troubleshoot"]{ 
    errorCode, 
    symptoms, 
    solution, 
    "relatedParts": relatedParts[]->{ partNumber, title } 
  }
}
Because the relational reference for SK16R11 strictly points to Toyota Corolla 2020, the AI agent reasons that it is strictly incompatible with the Toyota Camry 2023, preventing user error with 100% accuracy.
Screenshots
Tech Stack
Content Platform: Sanity.io Studio v3 & Content Lake
Query Language: GROQ
Frontend & API: Next.js 15 (App Router, Tailwind CSS, Lucide Icons)
AI Engine: Groq Cloud Llama API / OpenAI-compatible endpoint
Deployment: Vercel
Conclusion & Learnings
Building on Sanity's Content Lake made modeling complex multi-entity relationships effortless. Combining GROQ with AI agents unlocks reliable, zero-hallucination domain experts.

![ ](https://dev-to-uploads.s3.us-east-2.amazonaws.com/uploads/articles/qrfyxqt974q2i7j238r4.png)

Why VRAM (Not TFLOPs) Is the Real Gatekeeper for Local AI Coding in 2026

abdul rahman — Sat, 19 Sep 2026 10:13:21 +0000

Sending proprietary source code, enterprise database schemas, and client IP over third-party cloud APIs is rapidly becoming an unacceptable security liability.

For software engineers in 2026, the transition toward air-gapped, zero-leakage local AI workstations is no longer a hobbyist novelty—it is a prerequisite for code sovereignty.

However, many engineers making the jump make a critical hardware mistake: they chase GPU compute clock speed instead of memory bandwidth and VRAM allocation.

Here is what actually dictates local LLM performance, why VRAM is the ultimate gatekeeper, and how to configure a frictionless local AI setup.

⚡ 1. The Physics of Local LLMs: Why VRAM Bandwidth Dictates Speed

In generative AI inference, the bottleneck is rarely mathematical compute—it is sequential memory bandwidth. Generating every single token requires reading the entire parameter matrix from memory into the execution registers.

$$\text{Generation Speed (tok/sec)} \approx \frac{\text{Memory Bandwidth (GB/s)}}{\text{Model Size in Memory (GB)}}$$

Model Footprint: An INT4-quantized 70-billion parameter reasoning model requires ~40GB to 42GB of dedicated memory just to load into RAM, plus several gigabytes for KV cache context.
The Bandwidth Reality: A system with 400 GB/s bandwidth can theoretically push: $$400\text{ GB/s} \div 40\text{ GB} = \sim 10\text{ tokens/second}$$
Why Desktop DDR5 Fails: Standard dual-channel DDR5 desktop RAM tops out at 60–90 GB/s. Offloading model layers from VRAM to system RAM collapses generation speed to an unusable 1–2 tokens/sec.

⚔️ 2. The Architectural Fork: Apple MLX vs. NVIDIA Linux CUDA

When configuring a local compute engine, developers face two distinct hardware philosophies:

Option A: Apple Silicon Mac Studio (Unified Memory + MLX)

The Strength: Up to 192GB of Unified Memory accessible directly as VRAM. You can run massive 70B models (Qwen 2.5 Coder 72B or Llama 3.3 70B) completely in memory at a dead-silent 45W–75W power draw.
The Trade-Off: Apple MLX is fast, but CUDA remains the primary enterprise path for complex distributed frameworks.

Option B: NVIDIA Linux Rig (24GB–48GB VRAM + vLLM)

The Strength: 1,000+ GB/s memory bandwidth per card, native FP8 Tensor Core acceleration, and full ecosystem compatibility with vLLM, TensorRT-LLM, and LoRA fine-tuning.
The Trade-Off: High power consumption (450W to 800W+ for dual-GPU setups), significant thermal output, and fan noise.

🛠️ 3. The 3-Tool Zero-Leakage Offline AI Stack

You don’t need proprietary cloud subscriptions to get IDE-level autocomplete and chat. You can build an air-gapped pipeline in 10 minutes:

Inference Engine (Ollama / vLLM):


bash
   ollama run qwen2.5-coder:14b
Spins up an OpenAI-compatible REST API endpoint on localhost:11434.
IDE Integration (Continue.dev):
An open-source VS Code / JetBrains extension that hooks directly into your local Ollama instance with zero external telemetry.
Local Codebase Embedding (LanceDB / Chroma):
Indexes your entire local git repository into an on-disk vector database, enabling precise Retrieval-Augmented Generation (RAG) across all project files without touching the internet.
🪑 4. Don't Ignore the Physical Workstation Layer
Running local models transforms your workflow from passive typing to continuous high-throughput orchestration: IDE on one viewport, local agent chat on another, terminal token telemetry on a third.
code
Text
[ 34" Ultrawide WQHD (IDE + Architecture) ] ─── [ 27" Vertical Monitor (Local Agent Logs & Telemetry) ]
                                          │
                   [ Heavy-Duty Articulated Monitor Arms ]
                                          │
         [ Split Columnar Ergonomic Keyboard (Home-Row Modifier Layers) ]
Vertical Code Display: A secondary vertical monitor setup allows you to read 80+ lines of agent-generated code without scroll fatigue.
Biomechanical Input: Repetitive prompt engineering and modifier combinations (Ctrl, Alt, { }) trigger severe ulnar deviation on standard flat boards. Transitioning to a split ergonomic mechanical keyboard protects wrists during 10-hour sprints.
🎯 Final Thoughts
Privacy is the most compelling reason to run AI locally. Keeping your intellectual property, source code, and internal benchmarks on your own silicon is far more valuable than squeezing out marginal cloud tokens.
For full memory bandwidth benchmarks, token throughput matrices, and complete workstation procurement guides, read our complete technical audit: [Best Local AI Workstation Setup for Developers (2026 Hardware Guide).](https://www.besttechguidepro.com/2026/09/Best-Local-AI-Workstation-Setup-for-Developers.html)

Why Elite Software Engineers are Switching to 57 Vertical Input & Dual-Screen Setups (2026)

abdul rahman — Sun, 06 Sep 2026 12:38:51 +0000

When engineering complex systems, debugging microservices, or refactoring sprawling codebases for 8–10 hours daily, the hardware surrounding your IDE is the fundamental constraint on cognitive flow and physical endurance.

Recent electromyography (EMG) research confirms that traditional flat horizontal mice force the forearm into an unnatural 90° pronation, increasing carpal canal pressure and elevating Repetitive Strain Injury (RSI) risks.

1. The Biomechanics of the 57° Handshake Plane

Switching to a certified vertical ergonomic mouse aligns the radius and ulna bones into an anatomically neutral "handshake" posture:

Median Nerve Decompression: Eliminates continuous wrist pinching against hard desk edges.
Large Muscle Traversal: Shifts fine IDE tracking from wrist ligaments to the deltoid and upper arm.
🔗 Deep Dive Benchmark: Read the full Best Ergonomic Vertical Mice for Programmers (2026) guide.

2. Maximizing Viewport Density: The Vertical Monitor Advantage

Horizontally wide screens force excessive horizontal neck travel. Modern architectural layouts pair a primary ultrawide screen with a dedicated secondary vertical (portrait) display:

Displays 100+ continuous lines of code without scrolling fatigue.
Keeps full terminal logs, API documentation, and Git trees visible during runtime.
🔗 Screen Geometry Analysis: Explore our Best Vertical Monitors for Coding & Productivity (2026).

3. The Sit-Stand Umbilical Architecture

Static standing is just as harmful as static sitting. The standard for developer desks in 2026 requires dual-motor synchronization with zero screen oscillation:

Dynamic Load Distribution: Managing triple-monitor payloads over 220+ lbs without motor strain.
Zero-Wire Safety: Managing power bricks and dock lines through articulated cable spines.
🔗 Complete Analysis: Best Dual-Motor Standing Desks for Programmers.

Academic & Technical Citations:

CERN Zenodo Research: Maslmany, A. (2026). Heavy Industrial Mobility & Field Computing. DOI: 10.5281/zenodo.22537033.
Master Workstation Blueprint: High-Performance Workspace Architecture Encyclopedia.

Optimizing LLM Fine-Tuning Costs: Infrastructure & Engineering Guidelines

abdul rahman — Thu, 13 Aug 2026 22:00:19 +0000

When moving LLM fine-tuning from prototype notebooks to production pipelines, compute cost is rarely the only financial hurdle. Engineering setup, data preparation, evaluation cycles, and inference infrastructure often account for a massive portion of the total cost of ownership (TCO).

Here is a practical breakdown of how engineering and infrastructure decisions directly impact the total expenditure of custom model deployment.

1. Dataset Curation vs. Raw Compute

A common mistake in custom AI projects is assuming that parameter scale requires massive dataset volume. In practice:

Quality > Volume: A curated dataset of 2,000 highly accurate instruction-response pairs consistently outperforms 50,000 unverified examples.
Cost Impact: Data cleaning, deduplication, and format validation are upfront labor costs. Investing early in data quality reduces expensive iterative re-training runs.

2. Parameter-Efficient Techniques (PEFT & QLoRA)

Full-parameter fine-tuning of 7B, 8B, or 70B models demands distributed multi-GPU nodes, driving cloud hardware bills through the roof.

By applying QLoRA (Quantized Low-Rank Adaptation):

Base weights are quantized to 4-bit precision.
Trainable LoRA adapters are injected into specified attention modules.
Compute memory requirements drop significantly, making training feasible on far smaller hardware setups.

3. Serving Infrastructure: Managed API vs. Self-Hosted

Once trained, hosting strategy dictates your recurring monthly bill:

Managed APIs / Serverless: Best for low-to-moderate or unpredictable query volumes. You pay per token or compute execution time with near-zero DevOps maintenance.
Dedicated Self-Hosted GPUs: Utilizing optimized inference engines like vLLM or TensorRT-LLM becomes cost-effective once request traffic hits predictable high-volume thresholds.

For an in-depth breakdown of budget scenarios, break-even token thresholds, and financial models for custom LLMs, check out the comprehensive resource on [LLM Fine-Tuning Cost Analysis]

Key Takeaway

Always evaluate your project using a holistic total cost framework rather than GPU training prices alone. Measure employee time saved, accuracy gains, and API cost reductions against deployment and maintenance overhead to determine true project ROI.