-
The Field Notebook, Part 11: Voice-Chain Lines — Frames, Colours & Teardown Reasons
How to read GopherTrunk's composer voice-chain log — the voice-follow start and end lines, speech_frames and tch_frames, the bfi_count bad-frame counter, the TETRA DMO seed lines, and the undecoded_drops and concurrency_suppressed counters that look alarming but work exactly as designed.
-
The Field Notebook, Part 10: Recorder Lines — Spans, Segments & Dead Keys
How to read GopherTrunk's recorder log — call started and call ended with its reason field, the audio_pct that catches a recording shorter than its call span, the dead-key drops that leave nothing on disk, the per-transmission segment rolls, and the retention sweeper lines that tidy up behind them.
-
The Field Notebook, Part 9: Capture Lines — Aligning a Capture to the Log
How to read GopherTrunk's siglab capture-started, capture-ended and capture-aborted log lines, line a recorded IQ file up with the daemon's decode log by timestamp, and recognise the two capture failures — a centre carved at the wrong frequency and a FLAC rate refusal — before they cost you an afternoon.
-
The Field Notebook, Part 8: The MRC Health Line
How to read GopherTrunk's soapyremote MRC diversity branches health line — branch_dbfs, coherence, branch_gain_db, branch_phase_deg, updates and holds, lock_gate — the anchor and inter-branch delay lines around it, the four WARNs and how their text history changed, and which Weak-Signal or Analog Edge post to open when a two-antenna rig stops earning its keep.
-
The Field Notebook, Part 7: Overruns & host_drops — Reading a Downstream Signal
How to read GopherTrunk's overrun family — the soapyremote SDR overruns WARN with device_overflows and host_drops, the ccdecoder decode can't keep up WARN, the same-carrier voice tap dropped_chunks line and the runtime heartbeat — why each one points downstream at the decoder rather than at the radio, and the CPU story behind the 10 Sep dual-TETRA rig.
-
The Field Notebook, Part 6: The DMO Status Line — Noise Meters & Traffic Counters
How to read GopherTrunk's tetra dmo decode status line — dsb_total against dsb_schs_crc, the dnb_total noise meter against dnb_qualified, tch_crc, distinct_fn and the per-transmission scramble-seed fields — plus the seed recovered, seed changed and voice-follow lines around it, what healthy DMO prints, and when a counter means a defect.
-
The Field Notebook, Part 5: The DMR Activity Line
How to read GopherTrunk's widebandt2 channel decode activity line for conventional DMR — dibits, sync_hits, fec_pass, beacons, late_entries, rekeys, csbk_crc_fail and deaf_heals — what a healthy IPSC tap prints, what the deaf-tap heal WARN's receiver internals mean, and which DMR deep dive to open when a counter goes wrong.
-
The Field Notebook, Part 4: The Carrier-Offset WARN — Alias Buckets & Persistence
An operator's reading of GopherTrunk's issue
-
The Field Notebook, Part 3: The TETRA Decode-Status Line
An operator's field-by-field reading of GopherTrunk's tetra decode status line — sb_bursts, bsch_ok and bsch_fail, sch_pdus and sch_pdus_fail, frag_abandons — the "locked but deaf" signature where bsch_ok climbs while sch_pdus stays zero, and the signal-time resync and payload-drought watchdogs that recover it.
-
The Field Notebook, Part 2: Lock Lines — Locked, Lost & Transitions
An operator's reading of GopherTrunk's control-channel lock family — cc-hunt trying and locked, the per-protocol cc locked lines, the cc.lost events behind a re-hunt, cchunt hunt failed with its IQ diagnosis, the camped idle state, and the transition counter that turns "it drops sometimes" into a number.
-
The Field Notebook, Part 1: Startup — The Lines Before the First Lock
An operator's reading of GopherTrunk's startup log block — the two "gophertrunk starting" lines, device opened and gain set, and the config WARNs the daemon prints before its first lock, including the gain-in-tenths trap, two systems on one control tuner, and the pool gate that used to log nothing.
-
The Operator's Cookbook, Part 14: The Kitchen-Sink Config, Annotated
The series finale: one full GopherTrunk config.yaml walked section by section — sdr to systems to recordings to broadcast to api — each block annotated with the cookbook part that owns it, a decision table from goal to recipe, and the config hygiene that keeps a growing rig maintainable.
-
The Operator's Cookbook, Part 13: Naming Everything — Aliases, Labels & Exports
Turn every talkgroup and radio ID on your GopherTrunk rig into a name — the real talkgroup_file and rid_alias_file CSV columns, naming things live from the web console with the labels layer, harvesting talker aliases off the air, and exporting the merged catalogue back to CSV.
-
The Operator's Cookbook, Part 12: Two Antennas, One Signal — A Diversity Build
A complete GopherTrunk diversity build — a two-channel SDR over SoapyRemote with diversity mrc, reading the MRC health line (coherence, branch_phase_deg), choosing mrc vs mrc-static by hardware class, and the pre-combine capture A/B that proves whether combining actually helps.
-
The Operator's Cookbook, Part 11: The Closet Appliance — Pi, systemd & Docker
Turn a GopherTrunk rig into a headless 24/7 appliance — a Raspberry Pi or mini-PC under a hardened systemd unit, Docker with USB pass-through, honest LAN auth posture, sdr doctor preflight, runtime heartbeats and USB watchdogs, and the graceful shutdown that finally takes milliseconds.
-
The Operator's Cookbook, Part 10: The Archival Rig — FLAC, Retention & the Call Log
The keep-everything GopherTrunk build — lossless FLAC voice recordings at roughly half the size of WAV, FLAC IQ taps, the SQLite call log, retention sweeps that actually run, DSD-FME-playable vocoder sidecars, and disk-budget math with real byte rates.
-
The Operator's Cookbook, Part 9: Sharing the Feed — Broadcastify, OpenMHz & Friends
Turn a working GopherTrunk rig into a public feed — copy-paste broadcast config for Broadcastify Calls, RdioScanner, OpenMHz, Icecast and webhooks, the MP3 transcode and loudness settings that make uploads sound right, and a troubleshooting table for uploads that fail or vanish.
-
The Operator's Cookbook, Part 8: Radios Far Away — SoapyRemote, rtl_tcp & ka9q
A complete GopherTrunk recipe for putting the antenna where reception is and the decoder where the CPU is: sdr.soapy_remote, rtl_tcp and ka9q_radio config, the network bandwidth math per format, validated antenna-port selection, and why host_drops means your decoder stalled — not your network.
-
The Operator's Cookbook, Part 7: Many Systems, One Box — The SDR Pool
A complete GopherTrunk recipe for monitoring several trunked systems from one daemon: pinning dongles by serial, control vs voice vs wideband roles, sizing the shared voice pool against concurrent calls, and the priority, scan-list and preemption rules that decide who gets a radio.
-
The Operator's Cookbook, Part 6: Analog FM & Tone-Out Paging
A complete GopherTrunk recipe for conventional analog FM — a real scan list with squelch, CTCSS/DCS tone gating and per-channel hangtime, plus Quick Call II two-tone fire paging alerts, built on the scanner.conventional and tone_out config sections with every key verified.
-
The Operator's Cookbook, Part 5: TETRA Direct Mode — Scanning DMO
A complete GopherTrunk recipe for TETRA DMO — radio-to-radio direct mode with no infrastructure. One dongle camped on a simplex frequency, the tetra-dmo protocol, colour-code auto-recovery, the tetra_mcc/tetra_mnc keys an MNI≠0 network requires, and an honest account of what is still on-air-gated.
-
The Operator's Cookbook, Part 4: A TETRA TMO Rig
A complete GopherTrunk build for a TETRA trunked-mode network — one dongle camped on a 25 kHz control carrier, the CC equalizer that now ships enabled, MCC/MNC identity, four-slot same-carrier voice through the clean-room ACELP vocoder, and the sync-loss troubleshooting that came from real field logs.
-
The Operator's Cookbook, Part 3: One Repeater, Two Conversations — Conventional DMR
A single-dongle GopherTrunk build for a conventional DMR Tier II repeater — two independent talkgroups on TS1 and TS2 decoded as two simultaneous calls, with the interleaved two-slot voice path, embedded-LC routing, colour-code pinning, and the honest edge cases.
-
The Operator's Cookbook, Part 2: A DMR Tier III Network, End to End
A complete GopherTrunk build for trunked DMR — one wideband dongle on a Tier III control channel, the LCN-to-frequency band plan problem (and letting GopherTrunk learn the plan off the air), plus the log lines, colour codes and timeslots that tell you it's working.
-
The Operator's Cookbook, Part 1: The $40 P25 Starter Rig
A complete first GopherTrunk build — one RTL-SDR dongle, the stock whip, and a laptop decoding a local P25 Phase 1 system, with a copy-paste config.yaml, the exact log lines a healthy first run prints, and a troubleshooting table for when it won't lock.
-
The Analog Edge, Part 14: The Field Checklist — Is It RF or Is It Software?
The whole series folded into one triage flow — dBFS, clipping, gain sweep, rate A/B, capture, coherence — a decision tree for splitting radio problems from software problems, the order to spend hardware money in, and the send-off for the marginal system that started it all.
-
The Analog Edge, Part 13: Coherence, Not dBFS — Scale-Invariant Health
The story of an operator who raised front-end gain seventeen decibels to push a number past a software constant, and the scale-invariant cross-correlation that replaced the gate — why coherence answers the question a calibrator actually asks, and why DC removal inside it is load-bearing.
-
The Analog Edge, Part 12: Front-End Classes — Shared LO vs Independent PLLs
Why two receive channels on one chip keep a constant relative phase while two daughterboards with their own synthesizers lock at a random phase and walk afterwards, how that hardware class decides between mrc and mrc-static, and how the branch_phase_deg log field identifies your class without recording anything.
-
The Analog Edge, Part 11: Two Antennas — Diversity & MRC From the Operator's Seat
What a second antenna and maximal-ratio combining actually buy on a fading trunking band, how to configure GopherTrunk's diversity mode and read its health log line, and the coherence signature that tells you when two antennas cannot be combined with one wideband gain.
-
The Analog Edge, Part 10: Capture Discipline — cfile, cs16, SigMF & Metadata
Why "get the raw capture" is the most repeated sentence in the GopherTrunk issue tracker, the IQ formats and sidecar metadata that make a capture usable, the tap points that decide what a recording can prove, and how a good capture turns a complaint into a regression test.
-
The Analog Edge, Part 9: Filters & LNAs — Adding Gain Without Adding Garbage
When a low-noise amplifier actually helps, why its position in the chain matters more than its gain figure, how bandpass and FM-notch filters buy back headroom on a hot band, and the decision rules for ordering filter, LNA, and coax so you don't amplify your own problems.
-
The Analog Edge, Part 8: Feedline & Connectors — Where dB Go to Die
Why the coax between your antenna and your SDR quietly costs more decode margin than any software setting — published loss figures per cable class at 800 MHz, the real price of every adapter, and why receive-side loss is worse than the half-your-power framing suggests.
-
The Analog Edge, Part 7: Antennas for Trunking Bands
Antenna craft for trunked-radio monitoring — which bands the systems actually live in, why antenna gain is a radiation shape rather than free signal, polarization, when height beats gain, and how to choose between a discone, a tuned vertical, and a yagi for a fixed system.
-
The Analog Edge, Part 6: Sample Rate — The Decode Path Doesn't Care; the Front End Does
Why GopherTrunk's decoders are deliberately rate-invariant — every capture rate is normalized to one per-protocol channel rate before the receiver ever runs — so a symptom that tracks the sample rate indicts the capture, plus what higher rates genuinely buy and the two warnings that mean the consumer fell behind.
-
The Analog Edge, Part 5: Phase Noise & Reciprocal Mixing — The Ten-Megasamples Lesson
The front-end failure no level meter can see: how oscillator phase noise smears modulation while leaving the carrier looking clean, retold for operators through the #764 verdict — same antenna, same signal, 10 dB of demod SNR gone at one sample rate and not the other.
-
The Analog Edge, Part 4: Clipping, Overload & Intermod
What front-end overload actually looks like from the samples up — rail-pinned IQ, the clip ratio as the authoritative verdict, intermodulation products that manufacture phantom signals as gain rises, out-of-band overload from FM broadcast, and why a clean clip ratio still doesn't clear the front end.
-
The Analog Edge, Part 3: Gain Staging — Never Chase a Software Threshold
How to set SDR front-end gain the measured way — the operator who raised gain 17 dB to clear a software constant by 0.2 dB, the ladder method scored by decode quality, autogain's lock-then-error-rate-then-lower-gain tie-break, and the tenths-of-a-dB config trap.
-
The Analog Edge, Part 2: dBFS — What the Number Means (& What It Doesn't)
A precise definition of dBFS for SDR operators — full scale, peak versus RMS, the readings GopherTrunk exports, and why two captures peaking at the same −48 dBFS can differ by 10 dB of usable signal, which makes dBFS a headroom meter and never a quality meter.
-
The Analog Edge, Part 1: Where the Software Ends
The signal chain from antenna to ADC and why no code change can fix a problem on the analog side of it — an inventory of GopherTrunk issue-tracker bugs that turned out to live in the samples, and the map of a 14-part field guide to the front end.
-
Signal Lab, Part 10: The Demod Bench — siglab sweep, Regression & Export
Signal Lab's demod benchmark, gophertrunk siglab sweep, synthesizes P25 Phase 1 across an SNR ladder on both the c4fm and cqpsk/lsm demod paths, decodes through the production pipeline, and prints measured demod quality against a theoretical symbol-error-rate reference with CSV export.
-
RF Scope, Part 10: Advanced — Tuning Segmentation, Selective Analyzers & Pipelines
The advanced rfscope guide — run a subset of analyzers with dependencies auto-pulled, tune segmentation for unusual bands, emit machine formats (json/jsonl/yaml/csv) for pipelines, and close the reverse-engineering loop from -frames-out into cryptolab, with a note on how rfscope's downconverter relates to GopherTrunk's DSP paths.
-
Crypto Lab, Part 10: The Subject Framework, alias & the Mercury Reveal
Crypto Lab's pluggable subject framework and its alias tool recover length-seeded, keyless byte obfuscators through four incremental, resumable modes — gauge, structure, cells, and fromseed — and finally reveal that the Mercury signal was never encryption at all, graded BROKEN, with the moral that obfuscation is not encryption.
-
Signal Lab, Part 9: Dissecting P25 — TSBK PDUs, Receiver States & the Sync Landscape
Signal Lab's deepest P25 view — collect_pdus surfaces every TSBK signaling block (decoded and CRC-failed) as a field-level dissection with a csv-pdus export, plus the C4FM and CQPSK receiver-state series, the soft-eye verdict, and the sync-landscape heatmap.
-
RF Scope, Part 9: The Scene Cockpit — Live TUI & Web Console
rfscope cockpit is a full-screen Bubbletea terminal dashboard and rfscope serve is a browser console — both render the same live Scene (header, hierarchy tree, channel I/O sparklines, top talkers, conversations, severity-colored expert info) over a capture or a live SDR, with a Crypto Lab hand-off built in.
-
Crypto Lab, Part 9: The Web Console, Live-Capture Bridge & External Ciphers
Crypto Lab's serve command launches a schema-driven web console that auto-renders a form for every tool, mounts inside the daemon when built with the cryptolab tag, feeds ks and assess from a live decoder bridge, and drives operator-supplied external ciphers as CLI-only subprocesses behind a strict safety boundary.
-
Signal Lab, Part 8: Naming the Unknown — Blind Signal-ID & the Wideband Survey
Signal Lab identifies an unknown capture by ranking protocol candidates, names undecodable carriers from a blind symbol-rate and modulation estimate against an offline signal-ID reference database, and surveys a wide capture in the Wideband tab — where the Mercury signal finally gets a best guess but no lock.
-
RF Scope, Part 8: Expert Info — Anomalies & What They Mean
rfscope's expert analyzer is the RF analog of Wireshark's Expert Information — rule-based anomaly flags at note, warn, and alert severity for frequency hoppers, intermittent emitters, abnormally wide or narrow carriers, noise-like spectra, and the encrypted or obfuscated findings the entropy triage produced.
-
Crypto Lab, Part 8: Analog Voice Descrambling — Inversion, Split-Band, Rolling Code
Crypto Lab's descramble tool undoes analog voice privacy — frequency inversion, split-band inversion, and rolling-code hopping — operating on raw 16-bit PCM audio, and shows why analog scrambling is fundamentally weaker than digital encryption.
-
Signal Lab, Part 7: VSA — Lab-Grade Modulation Quality
Signal Lab's vector signal analyzer measures modulation quality like bench gear — carrier-frequency error, RMS and peak EVM split into magnitude and phase error, I/Q gain imbalance and quadrature skew, origin offset, an EVM-vs-symbol trace, and an error-vector spectrum.
-
RF Scope, Part 7: Entropy & Encryption Triage — The Crypto Lab Bridge
rfscope's entropy analyzer triages unidentified digital emitters — blind-demodulating a representative payload, running the cryptolab randomness battery and classify-auto measurements, and returning a verdict from plaintext to strong-encrypted with a recommended cryptolab command, plus a -frames-out file that hands the bytes to Crypto Lab.
-
Crypto Lab, Part 7: CRC Recovery & the Recipe Pipeline
Crypto Lab's crc recover reconstructs a protocol's CRC parameters — width, polynomial, init, reflection, and xorout — from sample frames, while recipe run chains transform and analysis operations into a CyberChef-style reusable pipeline for de-obfuscating RF payloads.
-
Signal Lab, Part 6: Synthesize — Building Ideal & Impaired References
Signal Lab's synthesis engine generates an idealized IQ capture and then injects controlled impairments — SNR, carrier offset and drift, multipath, DC, and I/Q imbalance — so you can build a clean reference or a known-bad regression fixture and overlay them in the Compare tab.
-
RF Scope, Part 6: Topology — Emitters, Frequency Hoppers & Conversations
rfscope's topology analyzer is the RF analog of Wireshark's Conversations and Endpoints — it clusters bursts into emitters by RF fingerprint, collapses a frequency hopper's scattered bursts into one logical source, links emitters into conversations, and defers to hunt's authoritative map when a trunking control channel decodes.
-
Crypto Lab, Part 6: The assess Battery — Attacking P25/DMR/TETRA
Crypto Lab's assess crypto harness runs every applicable attack against captured P25, DMR, and TETRA frames and grades each — cipher-strength, a published-weakness knowledge base, IV reuse, known-plaintext, weak/default keys against the real ciphers, and reduced-keyspace brute — landing on a RESISTANT, PARTIAL, or BROKEN verdict.
-
Signal Lab, Part 5: PSD, Spectrogram & Spectral Occupancy
Signal Lab's frequency-domain views — the power spectral density, the spectrogram/waterfall, and the spectral-occupancy metrics computed off the PSD: 99% occupied bandwidth, channel power, adjacent-channel power ratio (ACPR), and spectral flatness.
-
RF Scope, Part 5: Timing & Periodicity — Recovering the TDMA Frame
rfscope's timing analyzer builds burst-length and inter-arrival histograms per channel and recovers a TDMA or frame period by autocorrelating each channel's occupancy series, keeping only peaks above a minimum confidence — the time-domain counterpart to cryptolab's byte-period detection.
-
Crypto Lab, Part 5: Keystream Reuse — Many-Time-Pad & Crib-Dragging
Crypto Lab's ks tool exploits keystream reuse — the core real-world break against additive stream ciphers like P25 DES-OFB, ADP/RC4, and TETRA AIE — detecting IV/MI collisions with ks reuse and recovering plaintext with ks mtp via known-plaintext or crib-dragging, no key recovery required.
-
Signal Lab, Part 4: Constellations & Eye Diagrams — Seeing Modulation Quality
Signal Lab's constellation, eye diagram, and symbol scope — how to read clean versus noisy C4FM (four rails) and CQPSK modulation, what opening and closing eyes mean, and how these plots make EVM and SNR visible.
-
RF Scope, Part 4: The I/O Graph — Per-Channel Activity Over Time
rfscope's timeline analyzer is the RF analog of Wireshark's I/O Graphs — it groups bursts by frequency into channels and fills each with a 100-bin occupancy and power series plus duty cycle, occupancy percentage, burst rate, dominant class, and the sparkline the cockpit renders.
-
Crypto Lab, Part 4: Classical Ciphers — Brute XOR, Caesar, Vigenère, Substitution
Crypto Lab's brute tool recovers classical ciphers — repeating XOR, Caesar shift, Vigenère, and monoalphabetic substitution — using an embedded English trigram language model and optional cribs, with lfsr recovering the keystream of a linear scrambler.
-
Signal Lab, Part 3: The Browser Console — siglab serve and Live Decode
Signal Lab's browser console, gophertrunk siglab serve — a fully offline web app at 127.0.0.1:8099 with Captures, Synthesize, Identify, Wideband, and Compare tabs, upload-configure-run workflow, and a live SSE decode event stream.
-
RF Scope, Part 3: Protocol Hierarchy — What's on the Air
rfscope's hierarchy analyzer is the RF analog of Wireshark's Protocol Hierarchy — it groups bursts by modulation class, then occupied-bandwidth bucket, then names the protocol of the longest digital burst with siglab, attaching burst counts, airtime, spectrum share, and symbol volume to every node.
-
Crypto Lab, Part 3: Randomness — NIST SP 800-22 & the LFSR Signature
Crypto Lab's randomness battery runs a NIST SP 800-22 subset over a keystream bitstream — monobit, block frequency, runs, longest run, binary-matrix rank, spectral DFT, approximate entropy, serial, cumulative sums, and linear complexity — to tell strong keyed encryption from an exploitable LFSR scrambler.
-
Signal Lab, Part 2: Reading the Dashboard — Symbols, Baud, Lock & the 2% Rule
Signal Lab's terminal dashboard, field by field — protocol, symbols, effective baud versus expected, lock status and latency, symbol histogram, IQ imbalance, decode-error rate, EVM, and SNR — plus the ~2% baud-deviation rule that catches a wrong sample rate.
-
RF Scope, Part 2: From IQ to Bursts — The Segmentation Pre-Pass
rfscope's segmentation pre-pass turns a wideband IQ span into bursts — discovering carriers with a wideband FFT, estimating a robust noise floor, downconverting each carrier to a narrow baseband, and slicing onset→offset bursts with per-burst spectral metrics and a blind modulation class.
-
Crypto Lab, Part 2: First Triage — classify auto and stats scan
Crypto Lab's classify auto emits a ranked verdict for an unknown RF payload — plaintext, substitution, repeating-XOR, periodic scrambler, LFSR, or strong-encrypted — each with the exact next command, backed by the stats scan and stats period statistical triage.
-
Signal Lab, Part 1: Your First Capture — No Radio Required
Signal Lab is GopherTrunk's offline signal-analysis workbench — replay, identify, synthesize, and grade recorded IQ captures through the exact production decode pipeline with no SDR, no daemon, and no network attached.
-
RF Scope, Part 1: Wireshark for the RF Physical Layer
rfscope is GopherTrunk's protocol-agnostic RF network analyzer — point it at any band, recorded IQ or a live SDR, with no prior knowledge of the technology, modulation, framing, or encryption, and get a structured Scene of what is on the air and how it behaves.
-
Crypto Lab, Part 1: Breaking It Is the Test
Crypto Lab is GopherTrunk's byte-oriented cryptographic-research toolkit for security-testing RF encryption — shipped inside the binary but excluded from the default install behind a build tag, it attempts decryption by every applicable method and grades how far each one got.
-
Build in the Open, Part 14: The CLI Workflow & Claude Code as Your Daily Driver
Tie the whole idea-to-release journey into one repeatable loop using the gh CLI and Claude Code — CLAUDE.md, slash commands, hooks, MCP servers, and web sessions.
-
Build in the Open, Part 13: Advanced Git & GitHub Features
Level up beyond commit and push — interactive rebase, cherry-pick, bisect, reflog, worktrees, conflict resolution, plus Discussions, Codespaces, GHCR, and Environments.
-
Build in the Open, Part 12: Optimizing & Securing Your Repository
How to make your GitHub repo discoverable and safe — About box, badges, branch protection, secret scanning, Dependabot, SECURITY.md, and least-privilege tokens.
-
Build in the Open, Part 11: Releases — Cadence, Pre-Release vs. Release, SemVer & Changelogs
How to ship software releases the right way — Semantic Versioning, pre-releases, git tags, Keep a Changelog notes, and automated, checksummed builds.
-
Build in the Open, Part 10: Websites, Support Pages & GitHub Pages
How to give a project a free website — enabling GitHub Pages, a Jekyll static site, a custom domain via CNAME, support and sponsor pages, and a drip-released blog.
-
Build in the Open, Part 9: Documentation Done Right — What Lives Where
How to organize project documentation — README, CONTRIBUTING, SECURITY, CHANGELOG, in-repo docs — using the Diátaxis framework so docs are findable and don't rot.
-
Build in the Open, Part 8: Testing — How to Build and Write Tests
How to test software well — the testing pyramid, table-driven tests, golden files, race detection, coverage limits, and writing tests with Claude Code.
-
Build in the Open, Part 7: GitHub Actions — Which Workflows to Create and Why
Which GitHub Actions workflows most projects need — CI, security scanning, release automation, docs build, scheduled jobs — and how to gate merges with them.
-
Build in the Open, Part 6: Planning & Tracking Work — and Inviting Contributors
How to plan work with GitHub Issues, labels, milestones, and Projects, link issues to PRs, and onboard contributors with CONTRIBUTING, templates, and roles.
-
Build in the Open, Part 5: Branching & the Three Ways to Merge to Main
How to use Git branches and pick the right GitHub merge strategy — merge commit, squash & merge, or rebase & merge — with a clear "use this when" for each.
-
Build in the Open, Part 4: Git & GitHub Fundamentals (Using the Web Interface)
A beginner's Git mental model — commits, branches, remotes, the staging area — and how to create a repo, edit files, and open your first pull request entirely in the GitHub web UI.
-
Build in the Open, Part 3: Brainstorming Features with Claude & Writing the README as Your Roadmap
How to research a domain and brainstorm features with Claude Code, then write a README that doubles as a living roadmap — plus what CLAUDE.md is for.
-
Build in the Open, Part 2: Choosing Your Language, Platforms & Tech Stack
How to choose a programming language and tech stack — let your constraints (platforms, performance, distribution, team skills) decide, with GopherTrunk as a worked example.
-
Build in the Open, Part 1: Picking What to Build — How Pros Decide
How experienced developers choose what software to build — validating demand, scoping a first version, and avoiding the build-trap, with GopherTrunk as a worked example.