AI Coding
Evidence-led guidance for using coding agents and AI tools without giving up review, security, or understanding.
90 articles in this section.
Chrome Prompt API with Vercel AI SDK: where browser AI belongs
Built-in browser AI can reduce network trips, but it also creates device, model, and privacy differences. Start with tasks that tolerate missing capabil...
AI evaluation datasets: how to catch regressions before release
An AI feature can look better in a demo while becoming less reliable on the cases users actually care about. A small evaluation set with expected outcomes makes
AI coding agents and pull requests: a workflow that keeps humans responsible
AI coding agents can open useful pull requests, but speed does not remove ownership. A strong workflow makes scope, tests, permissions, and review evidence visi
Agentic security autofix: when an AI patch is safe to review
Agentic autofix is attractive because it can explore a codebase, propose a patch, and rerun analysis. The engineering risk is accepting a plausible fix without
GitHub AI security detections: what developers should verify before merging
AI-assisted security findings can widen coverage, but an alert is still a signal that needs triage. Here is how to review AI detections in pull requests without
AI-generated code review: a practical checklist before merging
A practical review process for AI-generated code that checks behavior, security, tests, dependencies, and maintainability before a pull request is merged.
Why open AI training data may matter more than the next model headline
Why datasets, documentation, licensing, and evaluation are becoming strategic AI infrastructure, and what developers should check before using an open dataset.
Hugging Face and NVIDIA’s training-cluster partnership explained
How Hugging Face and NVIDIA’s training-cluster collaboration works, what it offers researchers, and what open AI builders should check about cost, access, and licensing.
Local AI agents vs cloud agents: how to choose for real developer work
A practical comparison of local and cloud AI agents based on privacy, speed, cost, context, reliability, and the kind of work you need the agent to perform.
AI engineering careers in 2026: the skills junior developers should build
A practical guide to the skills AI engineering teams actually need, from backend fundamentals and evaluations to permissions, observability, and clear technical judgment.
How to measure whether an AI coding tool actually saves time
A practical guide to productivity measurement, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
Context engineering vs prompt engineering for real software work
A practical guide to context quality, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
How to review AI-generated code for security bugs
A practical guide to generated-code review, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
AI coding agents: what should be automated and what needs approval
A practical guide to automation boundaries, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
Model Context Protocol explained with a practical Node.js example
A practical guide to tool interoperability, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
How to redact API keys before sending code to an AI model
A practical guide to secret flow, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
Prompt injection in README files: how developers should protect AI agents
A practical guide to repository trust, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
How to build a permission system for AI agents
A practical guide to approval scope, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
Local AI agents vs cloud AI agents: privacy, speed, and real trade-offs
A practical guide to the privacy boundary, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
Nerva architecture explained: how a local-first AI agent should control its own actions
A practical guide to the control spine, with a concrete failure case, implementation trade-offs, and checks engineers can run before shipping.
What Nerva should build first: a realistic roadmap for a local AI agent
A realistic first-release roadmap for Nerva covering local tasks, permissions, context control, model adapters, verification, and the features that can wait.
Nerva privacy settings that would actually help developers
A practical privacy settings model for Nerva with local-only mode, cloud approval, path rules, redaction, retention, and visible task history.
Using Nerva to debug a Node.js backend without losing the thread
A focused Node.js debugging workflow for Nerva: capture the error, select relevant context, propose a fix, run a narrow test, and record what was verified.
Using Nerva to understand an unfamiliar JavaScript repository
A practical workflow for using Nerva to map an unfamiliar JavaScript or TypeScript repository while keeping context, edits, and tool access controlled.
How Nerva should recover when an AI tool call fails
A safe failure-recovery design for Nerva that explains errors, avoids silent escalation, preserves state, and asks before changing scope.
How Nerva can verify an AI action instead of trusting its final answer
A verification-first workflow for Nerva: check diffs, exit codes, tests, file state, and expected outcomes after an AI agent uses a tool.
Browser actions in Nerva: permission rules for an AI that can click
How Nerva could safely handle browser automation by showing destinations, actions, form data, downloads, and external side effects before approval.
Terminal command approval in Nerva: a safer way to run developer tools
A practical command-approval policy for Nerva: show the exact command, working directory, environment, network use, and verification before execution.
Why Nerva should show a diff before editing your code
A diff-first workflow for Nerva that lets developers review proposed edits, protect uncommitted work, approve precise writes, and verify tests afterward.
Prompt injection in repositories: how Nerva should treat untrusted instructions
How Nerva can handle prompt injection in READMEs, issue comments, web pages, and downloaded files without letting untrusted text rewrite agent permissions.
Nerva secret redaction: how to keep API keys out of AI context
A practical secret-redaction workflow for Nerva: detect credentials, minimize context, preview removals, and block unsafe cloud requests.
How Nerva can connect multiple AI providers without locking you in
A provider adapter design for Nerva that keeps local models, compatible APIs, quotas, costs, errors, and user-selected routing separate.
Choosing a local model for Nerva on a normal laptop
A practical guide to choosing a local model for Nerva based on memory, context size, speed, task difficulty, privacy, and verification.
How Nerva could use SQLite for local task history and memory
A practical local storage design for Nerva using SQLite for tasks, approvals, context records, model routes, and verification history.
Why Nerva needs a Rust permission engine for sensitive actions
A practical explanation of Nerva's planned Rust permission engine and why file access, commands, secrets, network calls, and browser actions need an independent boundary.
Nerva's tool gateway: why an AI agent should not call tools directly
How Nerva's planned tool gateway can turn model proposals into narrow, validated operations for files, terminal commands, browsers, and other tools.
How Nerva should choose a model for each developer task
A practical model-selection policy for Nerva: match local or cloud models to privacy, capability, context size, speed, cost, and reliability.
Nerva context manager explained: selecting the right files for an AI task
How Nerva's planned context manager can select focused files, imports, tests, and logs without sending an entire repository to a model.
How Nerva's task manager could keep long AI work understandable
A practical task-management design for Nerva: checkpoints, resumable steps, approvals, failures, and clear progress for multi-step AI work.
Nerva architecture explained: the control spine behind a local-first AI agent
A practical explanation of Nerva's planned architecture: task manager, context manager, model router, agent loop, tool gateway, permissions, and verification.
What unlimited means in Nerva's local-first AI model
An honest guide to Nerva's planned unlimited experience: no artificial app message cap, but real provider quotas, device limits, model costs, and permission boundaries still apply.
Nerva vs a normal AI chatbot: what changes when the agent can use your computer
A simple comparison of Nerva and ordinary AI chatbots, including local context, tools, permissions, model choice, privacy, and the risks of letting an agent act.
Nerva's context firewall: keeping private files out of the wrong AI request
How Nerva can classify, minimize, and review context before it reaches a local model, cloud provider, tool, or agent task.
How Nerva should handle permissions before an AI agent takes action
A practical design for Nerva's planned permission engine: separate model suggestions from file edits, terminal commands, network access, and other actions that need user control.
How Nerva can route work across local and cloud AI models
A practical model-routing design for Nerva: use local models by default, connect provider APIs when needed, and keep permissions, privacy, cost, and failure handling visible.
Nerva explained: a local-first AI agent for real work
Nerva is an upcoming local-first desktop agent designed to work with code, files, and tools while keeping permissions, model choice, and sensitive data under the user's control.
How Claude Code became an agent: product lessons for developer tools
Anthropic’s Claude Code retrospective describes its path from an internal CLI to a broader coding agent. Build around inspectable actions, permission boundaries, fast feedback, and real repository workflows.
Claude Sonnet 5: migration checklist for coding and agent workloads
Anthropic introduced Claude Sonnet 5 for coding, agents, and professional work at scale. Replay repository tasks, tool calls, and structured outputs before replacing the previous model.
Publish an AI Studio Android app safely to the internal test track
Google announced Play Console integration, browser emulation, ADB testing, and Internal Test Track publishing from AI Studio. Add source review, permission review, signing ownership, and device tests before publishing.
Migrate from Gemini CLI to Antigravity CLI without losing project rules
Google is unifying its agent development experience around Antigravity CLI and recommends porting Gemini CLI custom skills. Inventory every customization, migrate in a branch, and compare behavior on fixed tasks.
Evaluate AI-generated web interfaces from Gemini 3.5 Flash
Google says Gemini 3.5 Flash can generate richer interactive web interfaces and graphics. Test real data, empty states, localization, keyboard input, and constrained mobile widths.
Gemini 3.5 Flash for long-running agents: design checkpoints and recovery
Google highlights Gemini 3.5 Flash for longer agentic work through its Antigravity harness. Store checkpoints after planning, data collection, modification, and verification so work can resume safely.
Gemini 3.5 Flash vs larger models: choose with task-level evaluations
Google positions Gemini 3.5 Flash as combining flagship-level intelligence with Flash-series latency and strong coding and agent benchmarks. Compare completion rate, tool errors, latency, and cost on your actual tasks.
Secure cloud execution for coding agents: lessons from the Ona acquisition
OpenAI announced an agreement to acquire Ona for secure cloud execution and orchestration technology in the Codex ecosystem. Use ephemeral environments, minimum credentials, network policy, audit logs, and clean teardown.
How to migrate an AI feature to GPT-5.6 without breaking production
GPT-5.6 is generally available through the API as a new family rather than a byte-for-byte replacement for older models. Replay representative production cases in shadow mode and compare structured outputs before routing live traffic.
GPT-5.6 for frontend design: test visual quality instead of trusting a demo
OpenAI describes GPT-5.6 as making a notable step in design and end-to-end knowledge work. Evaluate generated interfaces across real content, keyboard navigation, and mobile viewports.
GPT-5.6 cost controls: budget AI workloads before switching models
GPT-5.6 offers different performance and cost points across Sol, Terra, and Luna. Set per-feature token, retry, and monthly budget limits before migration.
GPT-5.6 Sol vs Terra vs Luna: which model should developers choose?
OpenAI positions Sol as the flagship, Terra as the balanced everyday option, and Luna as the most cost-efficient member of GPT-5.6. Route a fixed evaluation set through all three and choose per task instead of setting one global default.
GitHub Copilot browser tools in VS Code: a safe testing workflow
Use Copilot browser tools in VS Code for navigation, screenshots, and web-app validation with domain controls, test accounts, and human review.
GitHub Copilot Vision: review screenshots, PDFs, and UI bugs safely
Use Copilot Vision with screenshots and PDFs for UI debugging while protecting private data, verifying visual claims, and keeping accessible tests.
GitHub Models retirement: migration checklist before July 30, 2026
Migrate projects from GitHub Models before retirement by inventorying API calls, prompts, credentials, evaluations, and replacement providers.
Copilot agent session streaming API: build a useful progress UI
Use Copilot agent session streaming to show progress, tool activity, failures, and completion without misleading users or leaking sensitive data.
Use Codex as an agent provider in JetBrains IDEs
Set up Codex as an agent provider in JetBrains IDEs, understand preview requirements, choose permissions, and verify changes safely.
Copilot usage API review cycles: measure AI adoption without bad metrics
Interpret Copilot usage API review-cycle and time-to-review metrics, avoid false productivity claims, and build a balanced engineering report.
Fix GitHub pull request merge conflicts with Copilot on mobile
Understand GitHub Mobile’s Copilot merge-conflict workflow, when it is safe, what to review, and when to return to a full development environment.
Deploy managed GitHub Copilot settings with MDM safely
Deploy organization-managed Copilot settings through MDM or files, test precedence, protect developer workflows, and prepare rollback.
GitHub Copilot OpenTelemetry export for VS Code and CLI explained
Understand enterprise-managed OpenTelemetry export for Copilot, choose useful signals, protect prompt data, and validate an approved collector.
GitHub Copilot repository overview: use it without trusting it blindly
Use Copilot repository overviews to enter unfamiliar codebases faster while verifying architecture, commands, ownership, and security assumptions.
Local vs cloud AI coding tools: privacy and speed tradeoffs
A balanced guide to local and cloud AI coding tools, including privacy, context size, speed, model quality, setup, and team governance.
Using AI on legacy code safely: understand before changing
A practical guide to using AI with legacy codebases: map behavior, add tests, avoid blind rewrites, and preserve business rules.
When AI refactors too much: how to keep changes reviewable
How to keep AI coding changes small, reviewable, and safe by limiting scope, separating refactors, and protecting behavior.
AI code diff review checklist before you merge
A practical review checklist for AI-generated code diffs: scope, tests, security, dependencies, error handling, and hidden behavior changes.
Slopsquatting explained: when AI suggests packages that do not really exist
A simple explanation of slopsquatting, hallucinated package names, and why AI-generated install commands need verification.
MCP server permissions explained: what to check before connecting one
A practical guide to MCP server permissions, tool access, OAuth, data exposure, and what developers should review before connecting AI tools.
Prompt injection in coding agents: why repo access changes the risk
A practical explanation of prompt injection risks in coding agents that can read repos, edit files, call tools, or open external pages.
AI-generated tests explained: useful safety net or fake confidence?
How to use AI-generated tests without fooling yourself, including assertions, edge cases, fixtures, and reviewer judgment.
AI coding tool rules: what every repo should tell Copilot or ChatGPT
A practical repo rules checklist for AI coding tools: architecture boundaries, tests, security, style, dependencies, and review expectations.
Copilot cloud agent explained: what developers should review before merging
How GitHub Copilot cloud agent changes the development workflow, what to inspect in generated branches, and how to keep ownership clear.
Copilot custom instructions: how to make AI coding tools follow your project rules
A practical guide to GitHub Copilot custom instructions, repository guidance, coding standards, and avoiding repetitive AI mistakes.
GitHub Copilot code review explained: how to use it without trusting it blindly
How to use GitHub Copilot code review as a helpful second reviewer while still keeping human judgment, tests, and security checks in control.
Using AI to understand an unfamiliar codebase
How to use AI tools to map an unfamiliar codebase without trusting summaries blindly or missing important architecture.
Security risks of copy-pasting AI-generated code
The security mistakes developers should check before copying AI-generated code into authentication, APIs, database queries, or deployment scripts.
Agentic coding tools explained: useful workflow or hype?
What agentic coding tools do, where they help, where they fail, and how developers should use them safely.
How to debug code with ChatGPT or Claude without getting misled
A practical prompt pattern for debugging code with AI tools while preserving logs, constraints, and your own reasoning.
Cursor vs GitHub Copilot vs ChatGPT for developers
A practical comparison of Cursor, GitHub Copilot, and ChatGPT for coding, debugging, refactoring, and learning.
Why developers do not fully trust AI coding tools yet
Why developers use AI coding tools but still distrust their output, and how to use them without lowering code quality.
AI-generated code review checklist for developers
A practical checklist for reviewing AI-generated code before merging it into a real project.
Best AI tools for students and job seekers in 2026
A practical tool-category guide for students and job seekers: writing, research, resumes, interviews, notes, and portfolio proof.
Best free AI tools for job seekers in 2026
A practical guide to free AI tools for job seekers in 2026, covering resumes, ATS checks, interview practice, job tracking, cold emails, and safe usage.
Best free AI tools for students in 2026
A practical student guide to free AI tools for studying, writing, research, coding, design, resumes, and interview prep, with simple examples and safe ways to use them.