lox

Prune low-signal unit tests aggressively. Agents often write tests that restate the implementation, always pass, break on every refactor, and add little protection beyond existing tests.

Prefer a smaller suite that protects behavior over a large suite that protects coverage numbers.

Keep a test only if all of these are true:

• It protects a specific observable behavior, invariant, or contract.
• There is a concrete, credible regression its assertions would detect.
• Its expected results are justified independently of the implementation under test.
• It adds meaningful value beyond other retained tests: a distinct failure mode, an important edge case, or substantially faster, more reliable, or more precise feedback.

lox

#!/usr/bin/env bash
set -euo pipefail

# Only applies to GitHub PR merge-ref builds.
[[ "${BUILDKITE_PULL_REQUEST:-false}" != "false" ]] || exit 0
[[ "${BUILDKITE_PULL_REQUEST_USING_MERGE_REFSPEC:-false}" == "true" ]] || exit 0

pr="$BUILDKITE_PULL_REQUEST"
remote="${BUILDKITE_GIT_REMOTE:-origin}"

lox

#!/bin/bash

# Script to fetch Pull Request review comments based on the current Git context.

set -euo pipefail # Exit on error, unset variable, or pipe failure

# --- Configuration ---
# Prefer 'origin' remote, fall back to 'upstream'
readonly PRIMARY_REMOTE="origin"
readonly FALLBACK_REMOTE="upstream"

lox

steps:
  - label: ":key: Test OIDC Token"
    command: |
      # Request an OIDC token
      echo "--- :buildkite: Requesting OIDC token"
      BUILDKITE_OIDC_TOKEN="$(buildkite-agent oidc request-token)"
      
      echo "--- :mag: Token details"
      # Print token (redacted in logs for security)
      echo "Token: \$BUILDKITE_OIDC_TOKEN"

lox

Step Templates

As there get to be more Buildkite plugins that are useful, the challenge is they clutter up pipelines and it's hard to make cross-cutting changes to the plugin configuration.

What if there was top-level block for creating templates for steps that was basically just top-level properties that would be copied to the steps?

It's an incremental solution vs a redesign of plugins, but it would allow for much cleaner templates.

The attached example is a very simple pipeline, but I've seen long pipelines with lots and lots of plugins, it's a mess!

lox

import os
import argparse
import requests
from datetime import datetime

# Define the parser for command line arguments
parser = argparse.ArgumentParser(description='Groq Whisper transcribe')
parser.add_argument('file', type=str, help='Audio file to transcribe')
parser.add_argument('--output_file', type=str, help='File to write output', default="transcription.txt")
args = parser.parse_args()

lox

# Check for Nvidia Hardware
lspci | grep -i nvidia

# Update
apt update
apt upgrade

# Install Nvidia drivers
apt install nvidia-driver-535 nvtop

lox

# https://help.drata.com/en/articles/4994112-gcp-connection-details

# Create a new project for Drata Integration
resource "google_project" "drata" {
  name                = var.project_name
  project_id          = var.project_id
  org_id              = var.org_id
  billing_account     = var.billing_account_id
  auto_create_network = false
}

lox

import { BatchInterceptor } from '@mswjs/interceptors'
import { ClientRequestInterceptor } from '@mswjs/interceptors/ClientRequest'
import { FetchInterceptor } from '@mswjs/interceptors/fetch'
import http from 'http'

const interceptor = new BatchInterceptor({
  name: 'my-interceptor',
  interceptors: [new ClientRequestInterceptor(), new FetchInterceptor()],
})

lox

// See https://cloud.namespace.so/docs/federation/gcp

locals {
  roles = [
    "roles/resourcemanager.projectIamAdmin", # allow managing identity
    "roles/editor",                          # allow to manage all resources
    "roles/iam.serviceAccountAdmin",         # allow to manage service accounts
  ]
}