Justin Scroggins
Infrastructure → SDET & Automation → Software Developer
Privacy enthusiast. Building censorship-resistant systems. Breaking things to understand them. Currently obsessed with distributed systems and making the web more decentralized.
CI/CD Platforms Are Becoming the AI Control Plane
In the age of AI agents, CI/CD is no longer just where code gets built. It is where intent, identity, policy, feedback, and deployment all meet.
Kimi K2.6 Max in OpenCode With Devcontainers and Local Ollama Workers
Kimi K2.6 Max just landed, and my early OpenCode testing with a devcontainer-first workflow plus background delegation to local Ollama workers is promising enough that it feels like a real glimpse of where hybrid AI coding stacks are headed.
Building ai-hooks: Guardrails for AI Coding Agents
The real challenge with AI coding agents is not code generation. It is making sure they act with the right product context, boundaries, and feedback loops.
Evaluating AI Coding Agents in Practice
Most AI agent evaluations are measuring optimism, not capability. Useful evaluation starts with real tasks, explicit acceptance criteria, and a hard look at where autonomy actually breaks down.
AI Coding Agents Need Product Context, Not Just Repo Context
Giving an AI agent access to your codebase is useful. Giving it access to the why behind the code is what makes it consistently effective.
Stateful Agent Workflows and Recovery
The hard part of agent automation is not making the first step happen. It is making the tenth step recover cleanly when the seventh step partially succeeded.
Building Plannable: Autonomous PM-AI Agent
How I'm building an autonomous PM-AI agent that syncs issues, PRs, and conversations from your tools into a semantic knowledge base, with 5 AI agents continuously analyzing your work.
Arcium Examples Reference - Complete Source Code
Complete source code reference from Arcium's official examples repository covering Blackjack, Sealed Bid Auction, Voting, Coinflip, and more.
ArcInfer Build Journal
A chronological log of what I built, in what order, and what I learned at each step.
Arcium Developers Docs - RAG Notes
Condensed, query-friendly notes from Arcium's official documentation for debugging ArcInfer.
Setup, Deploy, and Operate
Quick start guide, prerequisites, localnet dev loop, devnet deployment, and critical implementation notes for ArcInfer.
Quantization, PCA, and the Classifier
The three modules that sit on top of the math foundation — weight quantization, PCA dimensionality reduction, and the production classifier architecture.
The Client-Side Inference Pipeline
Everything in this doc runs on the user's machine, before encryption. It's the bridge between human-readable text and the encrypted 16-dimensional input that enters the MPC cluster.
Fixed-Point Arithmetic: The Foundation of MPC Inference
How and why I built Q16.16 fixed-point from scratch, what each operation costs in MPC, and why I chose accumulate-then-truncate for dot products.
Neural Network Layers: From Linear Algebra to MPC Circuits
Building Linear layers with const generics, the square activation lesson that broke my first test, and why argmax replaces softmax.
Building ArcInfer: Confidential AI Inference on Arcium's MPC Network
How I built a confidential sentiment analysis demo that runs neural network inference on encrypted data using Arcium's Multi-Party Computation network.
Building MCP Servers: Giving AI Agents Real Tools
How Model Context Protocol servers let Claude and GPT interact with your actual systems, not just talk about them.
Building s3cli: A CLI for Any S3-Compatible Storage
With the CLI vs MCP debate heating up, I built s3cli - a lean CLI tool that AI agents can use directly instead of requiring an MCP server. Here's how it works.
Building ai-tools: Universal Configuration for AI Coding Tools
How I built an open-source framework that lets you define hooks, MCP servers, agents, skills, and rules once — works across Claude Code, Cursor, Codex, Gemini CLI, and 9 others.
What Good MCP Tools Look Like
Most MCP tool design problems are not protocol problems. They are interface problems. Good tools are narrow, legible, low-ambiguity, and designed around what models actually do well and badly.
AI-Powered E2E Testing: Shift-Left with Playwright CLI
A practical series on direct API coverage, fluent seeding, and short UI tests that stay readable under real complexity.
Building Agentful: Parallel Agent Orchestration for Claude Code
How I built a pre-configured development toolkit that orchestrates specialized agents in parallel with inter-agent communication to build features from product specs.
Putting It Together: 2-Line E2E Tests That Stay Honest
The point is not literally two lines. The point is small, readable tests whose setup is deliberate because lower layers already did their jobs.
Inline Data Seeding: The .as() Method
Seed test data inline before page interactions - the .as() method that makes 2-line tests possible.
Fluent Form Builders: The FormBuilder Pattern
Form builders are the UI-side equivalent of seeding builders: they turn repetitive browser input into a small, readable vocabulary.
Page Components: Beyond Simple POM
Once setup is handled elsewhere, page objects can get smaller, clearer, and much more honest about what the browser layer is actually doing.
Expanding Coverage: CommentBuilder & UserBuilder
Once setup is local, you need more than one builder. Add user and comment seeding so higher-level API and UI tests stay short and readable.
One-Line Cleanup: The destroyWithAllDeps Pattern
Safe cascade deletion with proper ordering. Ensure no orphaned data remains in your test database.
Builders as Seeding: Replace beforeEach Sprawl with One Line
Once lower-level APIs are covered directly, builders can do what they are actually good at: local, fluent setup for higher-level tests.
Negative Cases, Boundary Coverage, and a bugs.md That Actually Helps
Negative tests should not be an afterthought. Split them out, drive them from data, and keep a bug ledger that helps the next person.
Stop Hand-Writing Giant API Specs
Lower-level API coverage gets better when request helpers, validations, types, and scenarios stop living in one giant spec file.
The Foundation: TestDefaults & TestDataHelper
Building the random data generation foundation with TestDefaults and cleanup management with TestDataHelper.
Installing Playwright and Building Our Test Foundation
Setting up Playwright with TypeScript, configuring projects for API and UI testing, and writing our first baseline test.
Why We're Building a 2-Line E2E Testing Framework
The real problem is not builders. It is giant bespoke API specs, hidden setup in before hooks, and UI tests written without an API-first strategy.
FHIR APIs in Practice: Lessons from Healthcare Interoperability
Building FHIR-compliant APIs taught me more about REST design than any other project. Here's what I learned.
Designing Multi-Tenant Systems Without Regret
Multi-tenancy problems usually start as small convenience decisions. The systems that age well are the ones that treat tenant boundaries as architecture from day one, not a filter added later.
Kubernetes Homelab: From Zero to GitOps in a Weekend
Building a production-grade K8s cluster on consumer hardware with ArgoCD, Prometheus, and zero cloud costs.
Building Logarr: Mission Control for Media Server Stacks
How I built a unified logging, intelligent issue detection, and AI-powered analysis platform for Plex, Jellyfin, Emby, Sonarr, Radarr, and more.
From Manual to Autonomous: Building Self-Healing E2E Tests
How I built test suites that fix themselves when UI changes break them, reducing maintenance time by 73%.
Zero-Downtime PostgreSQL Migrations in Real Systems
Most database migration outages are self-inflicted. The fix is usually not fancy tooling. It is sequencing, patience, and a strict expand-contract workflow.
Contract-First API Testing with OpenAPI
Hand-written API tests drift for the same reason hand-written docs drift. The contract needs to become the source of truth for coverage, validation, and scenario planning.
Structured Logging for Real Root Cause Analysis
Most logging is optimized for writing, not debugging. Structured logging forces teams to log in a way that makes production problems actually traceable.
Docker Compose for Real Development Stacks
Docker Compose is still one of the fastest ways to create a dependable local platform, as long as you treat it like an integration contract instead of a pile of containers.