Pigfox

Blog

Field notes on OSINT, security checks, SEO, and safer hiring and vendor due diligence.

• Slack AI Lab and the engineering of visible Slack assistants

  2026-09-25

  Slack AI Lab shows a Slack bot answering from outside the workspace, which makes the system boundary easier to inspect. The useful signals are in request verification, identity mapping, tool routing, context handling, and message rendering, not in polished phrasing alone.

• ETL Lab and the case for stateless data pipelines

  2026-09-24

  ETL Lab demonstrates a strict idea in pipeline design: if you avoid durable intermediate state, you remove a major source of staleness. The useful question for your own systems is where correctness depends on remembered progress, and whether reruns from trusted inputs would be simpler to verify.

• LangDAG Lab and the engineering of branched conversations

  2026-09-23

  LangDAG Lab shows a simple point with broad engineering impact: once a conversation branches, a flat transcript stops being an honest model. The demo is a useful lens on ancestry, replay, evaluation, and the failure modes of branch-unaware chat systems.

• Rust Send/Sync Lab and the engineering of thread safety

  2026-09-22

  Rust Send/Sync Lab pairs Rust’s compile-time thread-safety guarantees with a runtime watcher. It shows how to inspect `Send` and `Sync` as design boundaries, how to verify them, and where concurrent systems often fail anyway.

• What Rust Borrow Lab Teaches About Borrow Checking

  2026-09-21

  Rust Borrow Lab shows two rejected borrow patterns beside a form the compiler accepts. The value is in the delta, because borrow-checking errors are easier to fix when you inspect lifetime shape, aliasing, and the smallest rewrite that changes the proof.

• Rust Move Lab and the engineering of ownership

  2026-09-20

  Rust Move Lab compares compile-time ownership checks in Rust with runtime value behavior in Go. It is a compact way to inspect moves, borrows, copies, and shared state without hand-waving.

• Rust Lifetime Lab and the boundary between lifetimes and escape

  2026-09-19

  Rust Lifetime Lab shows a precise boundary between Rust borrow checking and Go escape analysis. It teaches you what to inspect in code, how to verify compiler behavior, and where hidden heap allocation changes the trade-off.

• Goroutine Visualizer and the myth of killing work

  2026-09-18

  Goroutine Visualizer shows a core property of Go concurrency: pressing kill on a goroutine does not give you abrupt external termination. The useful lesson is how to design, verify, and observe cooperative cancellation so work exits cleanly under load and during shutdown.

• Cosmos Lab and the engineering of replay refusal

  2026-09-17

  Cosmos Lab shows the part of proof verification that matters most in production, refusing replayed inputs. The engineering lesson is simple: valid cryptography is not enough without context binding, freshness rules, and one-time consumption state.

• RAG Lab and the engineering of measured retrieval

  2026-09-16

  RAG Lab shows a retrieval-augmented generation pipeline as a measured system, with failures exposed instead of hidden. The useful lesson is not the answer text, it is how to inspect retrieval, context assembly, and grounding when the system misses.