Test DST Gaps and Folds in Agent-Written Python Schedules
Resolve a proposed local schedule to UTC only after rejecting missing times or choosing an explicit occurrence of a repeated time, then verify the policy with nine tests.
Documentation index
AI coding agent tutorials, setup notes, and operating checklists.
Historical archive entries are visible to readers while they remain noindexed and excluded from RSS, sitemap, and llms.txt.
Resolve a proposed local schedule to UTC only after rejecting missing times or choosing an explicit occurrence of a repeated time, then verify the policy with nine tests.
Bound a Go HTTP client’s JSON body before decoding it, then test exact-limit and chunked over-limit responses.
Hold a destination write open to expose eager production in an agent-written Node.js export, then verify complete output and visible write failures.
Check agent-written asyncio code with a runnable three-case test that verifies successful results, sibling cancellation after failure, and cleanup before caller cancellation returns.
Check agent-written PostgreSQL workers with an atomic claim statement, overlapping consumers, and explicit ownership recovery after a worker exits.
Review agent-written PostgreSQL upserts by checking conflict identity, allowed updates, empty results, and concurrent-writer evidence.
Review agent-written Kubernetes resource and workload changes by tracing node-pressure signals, eviction policy, Pod ranking, and recovery evidence.
Review agent-written admission policies and webhooks by tracing request matching, mutation, failure behavior, and final-object evidence before approval.
Review agent-written Kubernetes priority changes by tracing PriorityClass admission, queue order, preemption victims, quota boundaries, and candidate-specific scheduler evidence.
Review agent-written DaemonSet changes with a per-node coverage map, controller-added scheduling rules, update-budget calculations, and candidate-specific Pod evidence.
Review standalone Kubernetes Job changes by checking completion accounting, parallelism, retry budgets, deadlines, suspension, and candidate-specific evidence.
Review topology spread changes by checking counted Pods, eligible domains, skew arithmetic, and scheduler evidence for the rendered candidate.
Review agent-written tolerations against actual node taints, then verify scheduling exclusions and timed eviction with focused cluster evidence.
Review agent-written init containers for startup order, repeatable setup, shared-file handoff, and failure evidence before approving the workload change.
Review ServiceAccount changes by tracing Pod identity, token delivery, RBAC bindings, and revocation evidence.
Review node-affinity changes by resolving selector logic, checking label ownership, and testing actual placement in a representative cluster.
Review Kubernetes Secret changes by tracing stored values, API permissions, Pod access, delivery, rotation, and sanitized evidence.
Review agent-written Ingress changes by resolving the controller class, testing host and path boundaries, and verifying TLS through the intended endpoint.
Review agent-written Kubernetes Services by tracing selectors and named ports to the intended backends, then checking EndpointSlices and the client request path.
Review agent-written ConfigMap changes by tracing how each container consumes configuration, proving when the application loads it, and preserving a usable rollback target.
Review agent-written CronJob changes with explicit schedule windows, overlap policy, Job retry budgets, and evidence of duplicate-safe application behavior.
Review agent-written StatefulSet changes by checking stable identity, ordered updates, partitioned rollouts, and persistent-volume claims before approval.
Review agent-written HPA changes with CPU-request arithmetic, replica ownership checks, explicit scaling policies, and evidence from load and recovery tests.
Review agent-written Deployment changes with replica-budget arithmetic, revision-specific status checks, stalled-rollout tests, and explicit rollback limits.
Review agent-written PodDisruptionBudgets against the workload’s availability contract, then verify selector coverage, eviction behavior, and recovery evidence separately.
Review agent-written Kubernetes resource settings against namespace policy, then verify Pod admission, scheduling, and runtime behavior separately.
Review agent-written Kubernetes probes against application health handlers, then test startup, traffic withdrawal, recovery, and container restarts separately.
Review agent-written NetworkPolicy changes by resolving selectors, combining existing allowances, and testing permitted and forbidden connections in a disposable cluster.
Review agent-written Kubernetes workloads with explicit runtime restrictions, rendered Pod checks, and admission tests that distinguish rejection from warnings.
A two-stage GitHub Actions design that lets a coding agent test forked pull requests without giving untrusted code repository write access or secrets.
Review agent-written XPath with fixed expressions, bound variables, explicit namespaces, and tests that prove the exact authorized result set.
Review agent-written logging with fixed event fields, bounded structured records, sensitive-data exclusions, and tests of the collected output.
Review agent-written HTTPS clients with explicit trust stores, hostname checks, controlled certificate failures, and harmless local handshake tests.
Review outgoing HTTP headers with fixed field names, explicit value grammars, validation before response commitment, and harmless integration fixtures.
Review agent-written CSV exports with separate syntax and formula controls, explicit consumer profiles, and tests of the downloaded file.
Review agent-written password storage with explicit hash profiles, bounded verification, and login-time upgrades that preserve newer credentials.
Review agent-written session transitions with fresh login identifiers, narrow state migration, durable invalidation, and tests that replay the old cookie.
Review agent-written Kubernetes RBAC changes for least privilege, service-account binding, namespace scope, and denied-action evidence before applying them.
Review agent-written Jinja and Flask rendering code for untrusted template source, second-pass evaluation, excessive context, and unsafe fallback behavior.
Review agent-written PostgreSQL row policies against the runtime role, tenant context, write checks, and connection reuse before approving a patch.
Review agent-written XML handling with explicit DTD and resource policies, hardened processing stages, and tests that expose attempted file or network access.
Review agent-written password recovery with explicit account binding, expiring single-use grants, safe email links, concurrent redemption tests, and session revocation.
Review agent-written OAuth authorization-code integrations with exact redirect binding, PKCE, state validation, token handling, and adversarial browser tests.
Review agent-written WebSocket channels with explicit origin, authentication, message, lifecycle, and resource controls before they reach users.
Review agent-written upload paths with explicit size, type, filename, storage, and cleanup contracts before an untrusted file reaches a worker.
Review agent-written CORS changes with exact origin allowlists, deliberate credential handling, and browser tests that expose unintended access to authenticated responses.
Review agent-written bearer-token middleware against an explicit JWT profile, then test signature, issuer, audience, time, and token-purpose boundaries.
Review agent-written API updates for unauthorized field writes, then prove narrow input contracts with explicit mapping and state-based regression tests.
Review agent-written cache changes with an explicit sharing policy, complete cache keys, and two-user tests that expose personalized responses crossing a shared boundary.
Review agent-written HTTP gateways for parser disagreement, strict message framing, and safe intermediary behavior, then prove the boundary with harmless fixtures.
Review agent-written deserialization paths as trust-boundary code, reject dangerous object reconstruction, and prove bounded data handling with a focused test matrix.
Review agent-written redirect handlers as navigation authority boundaries, then prove destination policy with safe allow cases and hostile URL tests.
Review agent-written rendering code with explicit text and HTML contracts, a narrow sanitizer policy, and adversarial tests of the final DOM.
Review agent-written browser endpoints for cross-site request forgery with explicit credential boundaries, request tokens, origin checks, and adversarial tests.
Review agent-written API changes for object-level authorization, then test another user’s records, tenant boundaries, and denied side effects.
Review agent-written database code for SQL injection with bound values, constrained query structure, and adversarial tests.
Review agent-written JavaScript for unsafe dynamic keys, recursive merges, and inherited configuration values, then prove a narrow normalization boundary.
Review agent-written URL fetchers as network authority boundaries, bind validation to connection, and prove redirects and special-use addresses fail closed.
Review agent-written temporary-file code as a creation-and-lifetime boundary, eliminate name-to-open races, and prove cleanup without exposing task data.
Review agent-written process-launching code as an authority boundary, keep data out of shell syntax, and prove failures are contained.
A review and test workflow that keeps agent-written archive extractors inside a disposable destination and fails safely on hostile entries.
A practical workflow for mapping sensitive paths to accountable reviewers and enforcing their approval before agent-generated pull requests merge.
Test retries, timeouts, expiration, and scheduled work with controlled clocks instead of wall-clock delays.
Use bounded retries, per-attempt evidence, and expiring quarantine rules to expose intermittent failures without turning a recovered test into a false green.
Build a focused merge gate that catches unsafe regular-expression complexity before an agent-written patch reaches production.
Build a repeatable CI gate that catches memory, goroutine, and open-handle leaks in coding-agent patches before merge.
A practical workflow for testing normalization, text boundaries, and confusable identifiers in coding-agent patches.
A practical CI contract for measuring coverage on modified lines, checking decision branches, and failing safely when evidence is missing.
Build a two-layer CI gate that compares GraphQL schemas and validates client operations before an agent-written patch can merge.
Build stable benchmark gates that separate repeatable slowdowns from measurement noise in coding-agent patches.
Build stable CI gates that catch harmful query-plan changes in coding-agent SQL and index patches.
A provider-neutral workflow for signing, verifying, and blocking untrusted coding-agent commits before they reach a protected branch.
Use randomized test execution and captured seeds to reveal, reproduce, and fix order-dependent failures in coding-agent patches.
A practical merge gate for checking software bills of materials produced by coding agent changes.
Use snapshot tests to make coding-agent refactors reviewable without freezing intentional behavior changes.
A practical workflow for having a coding agent bisect regressions while preserving reproducible classifications, logs, and CI artifacts.
Authenticate, filter, and deduplicate repository webhooks before they can enqueue coding-agent work.
A practical conformance and regression plan for ACP adapters, covering negotiation, capabilities, transports, sessions, permissions, and failure handling.
A practical design for pre- and post-tool hooks that enforce policy, preserve sanitized evidence, and behave predictably across coding-agent runtimes.
A practical way to turn module and layer boundaries into deterministic checks that stop agent-written dependencies before merge.
Test concurrency-sensitive agent patches with race detectors, reproducible schedules, and reviewable evidence.
A practical, source-backed gate for inspecting, sandboxing, and evaluating reusable Agent Skills before coding agents load them.
Learn how to fuzz agent-written parsers in bounded CI runs, preserve failures, and turn minimized inputs into regression tests.
A practical guide to using the MCP Tasks extension for durable, pollable coding-agent tool calls that can survive disconnects and restarts.
A practical workflow for turning Lighthouse measurements into a reviewable, branch-protected performance gate for coding-agent web patches.
A practical workflow for testing coding-agent patches against real databases and services in isolated, disposable containers locally and in CI.
Verify coding-agent patches in clean, controlled build environments that expose undeclared files, tools, caches, and machine-local assumptions before merge.
Build a practical merge gate that combines automated accessibility scans, targeted human checks, and reviewable evidence.
A practical workflow for linting and diffing OpenAPI contracts changed by coding agents before those patches reach clients.
A practical rubric for scoring coding-agent patches when tests, behavior, and review quality do not line up.
Design a deny-by-default egress policy for coding-agent sandboxes, test approved destinations, and capture safe evidence when network access fails.
A practical workflow for scanning AI coding agent pull requests, publishing SARIF evidence, and deciding when a change can merge.
A practical workflow for checking dependency provenance, lockfile integrity, and review evidence when a coding agent changes a repository.
Learn how to turn behavioral invariants into generated tests, capture minimal counterexamples, and guide safer coding-agent repairs.
A practical workflow for reviewing coding-agent deployment changes and replacing mutable image tags with verified, digest-pinned references.
Configure merge queues so agent-authored pull requests are tested against current branch state and queued changes before they merge.
Learn how targeted mutation tests reveal weak assertions and show whether agent-written tests can detect meaningful faults.
A practical guide to recording, signing, and verifying build provenance for coding-agent-generated artifacts before release.
A practical workflow for scanning agent-authored Terraform plans, reviewing destructive changes, and requiring human approval before apply.
A practical workflow for inspecting agent-written database migrations, testing data safety, and proving a recovery path before merge.
A practical dependency admission workflow for verifying coding-agent package suggestions before installation, script execution, or merge.
Contain repository prompt injection by separating untrusted content from agent authority, limiting tools, and requiring human approval.
A practical retention workflow for keeping coding agent worktrees available while reviewers inspect pull requests, rerun checks, and request follow-up changes.
A practical recovery workflow for restarting a coding agent after interruption while keeping repository state, instructions, diffs, and pull request evidence intact.
A practical guide to choosing between terminal, IDE, cloud, pull request, and CI surfaces for coding agent work.
A practical workflow for checking repository instructions, memory files, task scope, and worktree state before a long coding agent session drifts away from the intended task.
A practical guide to capturing what a coding agent changed, what it intentionally left alone, and what a reviewer should verify before opening a pull request.
How to structure a coding agent CI repair loop: detect a failing CI run, hand the failure context to an agent, validate the fix, and gate the PR without losing evidence or spinning into runaway retry cycles.
A practical rule set for assigning parallel coding agents to separate Git worktrees, branches, and pull request handoffs.
A practical workflow for checking coding agent outputs against repository instructions, official documentation, diffs, and a short evidence log.
A practical checklist for handing a coding-agent pull request to reviewers with scope, checks, instruction context, risk notes, and clean pass/fail records.
A practical boundary plan for giving coding agents useful repository context while keeping credentials, deployment rights, and CI tokens under human control.
A practical pattern for writing task briefs that give coding agents enough repository rules, acceptance criteria, and review handoff structure to produce changes a human can inspect.
A practical guide to writing repository-level instructions, agent rules, and task briefs that help coding agents work safely in real projects.
Use failing checks as the target, require a diagnosis before edits, keep diffs small, and report exact verification before review.
Build a small context stack for coding agents, then use Git worktrees and file ownership to keep parallel attempts reviewable.