I don’t think it’s necessary to introduce Gregor Hohpe. I’m a big fan, having read Enterprise Integration Patterns, and I’ve recommended the book ever since. When I spoke at the Software Architecture Gathering in 2024, I was fortunate enough to meet him and purchase this book. I’m the happy owner of a signed copy.

Modern architects don’t try to be the smartest people in the room–they make everyone else smarter. They ride the Architect Elevator from the penthouse, where the business strategy is set, to the engine room, where the enabling technologies are implemented. They shun popular buzzwords in favor of decision discipline and clear communication across levels.

Facts

• 41 chapters
• €54.81
• 365 pages
• The author has previously co-authored Enterprise Integration Patterns, of which I’m a huge fan

Chapters

1. Architects
   1. The Architect Elevator
   2. Movie-Star Architects
   3. Architects Live in the First Derivative
   4. Enterprise Architect or Architect in the Enterprise?
   5. An Architect Stands on Three Legs
   6. Making Decisions
   7. Question Everything
2. Architecture
   1. Is This Architecture?
   2. Architecture Is Selling Options
   3. Every System Is Perfect…
   4. Code Fear Not!
   5. If You Never Kill Anything, You Will Live Among Zombies
   6. Never Send a Human to Do a Machine’s Job
   7. If Software Eats the World, Better Use Version Control!
   8. A4 Paper Doesn’t Stifle Creativity
   9. The IT World Is Flat
   10. Your Coffee Shop Doesn’t Use Two-Phase Commit
3. Communication
   1. Explaining Stuff
   2. Show the Kids the Pirate Ship!
   3. Writing for Busy People
   4. Emphasis Over Completeness
   5. Diagram-Driven Design
   6. Drawing the Line
   7. Sketching Bank Robbers
   8. Software Is Collaboration
4. Organizations
   1. Reverse-Engineering Organizations
   2. Control Is an Illusion
   3. They Don’t Build ‘Em Quite Like That Anymore
   4. Black Markets Are Not Efficient
   5. Scaling an Organization
   6. Slow Chaos Is Not Order
   7. Governance Through Inception
5. Transformation
   1. No Pain, No Change!
   2. Leading Change
   3. Economies of Speed
   4. The Infinite Loop
   5. You Can’t Fake IT
   6. Money Can’t Buy Love
   7. Who Likes Standing in Line?
   8. Thinking in Four Dimensions
6. Epilogue: Architecting IT Transformation
   1. All I Have to Offer Is the Truth

Pros and cons

You might have noticed that there are lots of chapters. Yet, the book isn’t “big”. Thus, each chapter is between 5 and 10 pages. To me, it’s a big plus: I can focus much better on a small chapter before going to sleep than to slice a chapter between multiple sessions or increase my reading span.

The author speaks from experience. Many sections in the book spoke to me, as something I had experienced in my professional life. Think “experience distilled” in a book.

If you are into technical stuff, you’ll be disappointed. The book is strictly about organization-related matters. On this side, it’s a trove of wise advice.

The book is segmented into chapters, but I think they can be read in any order, as each is cohesive enough. Early chapters tend to reference later chapters less than the opposite. That might be the only reason for the sequence.

The book’s advice, just like any other, can’t be applied blindly. Experience is hard to transmit as it is. You need to carefully read each advice multiple times, analyze its context, evaluate your context, try to apply it, then measure. Rinse and repeat. Yes, organizational matters are more complex to handle than technical ones.

While the subject is serious and the anecdotes relevant, the tone is humorous. Some might like it, some might not. I belong to the former crowd.

Conclusion

If you already have a couple of years of experience and feel your technical skills aren’t enough, I’d definitely recommend this book.

To go further:

• The Software Architect Elevator
• Just finished reading “The Software Architect Elevator”

Originally published at A Java Geek on March 22^nd, 2026.

When Private Equity firms evaluate AI-driven companies in 2026, they’re no longer asking “Does it use AI?” They’re asking “Can we audit it? Can we scale it? Can we sell it?” Most startups fail this test because they’ve built chatbots, not systems. The difference costs millions at exit.

The Hybrid AI Workbench is not just a software application; it is a standardized operating system for high-volume, high-variance knowledge work. Whether it is due diligence, market mapping, or regulatory audits, the Hybrid AI Workbench provides a repeatable framework to convert unstructured human labor into an “audit-ready,” high-margin digital asset. This architectural approach transforms operational AI implementation from a cost center into a defensible competitive moat.

1. The Core Framework: A Five-Layer Reference Architecture

To avoid architectural sprawl and technical debt—especially in a portfolio context—CTOs should adopt a layered approach. This ensures that individual “agents” can be swapped as models improve, while the core business logic remains stable.

Layer 1: The Engagement Layer (Intent & SLA)

This is the interface where humans define the mission. It is more than a chat box; it is a Structured Task Definition engine.

• Function: Captures the “Brief,” sets compliance constraints, and establishes Service Level Agreements (SLAs).
• Value for PE: Standardizes inputs across different business units, a core tenet of effective Business Process Optimization, allowing for portfolio-wide performance benchmarking.

Layer 2: Orchestration & Agentic Mesh (The Brain)

Using frameworks like LangGraph Enterprise, this layer breaks the brief into a Directed Acyclic Graph (DAG).

• The Planner: A high-reasoning model (e.g., GPT-5 or Claude 4) that decomposes tasks.
• The Workers: Specialized agents (SQL experts, web navigators, data cleaners).
• The Critic: A dedicated verifier agent that audits the output before it ever touches a human.

Layer 3: The Human-in-the-Loop (HITL) Layer

This is the “Safety Valve.” It manages the handoff between AI uncertainty and human expertise.

• Function: Routes sub-tasks to internal employees or external experts based on skill tags and availability.
• Objective: In 2026, the goal is 10x Employee Efficiency. Instead of “doing” the work, employees move to a “review and refine” model.

Layer 4: Data & Knowledge Layer (Memory & Lineage)

Every action, tool call, and human correction is stored as a structured event.

• Tech Stack: Postgres (Relational), pgvector (Memory), and Snowflake/DuckDB (Analytics).
• Provenance: Every cell in a final deliverable must link back to its source URL or raw data point.

Layer 5: Platform & Security (The Foundation)

The “Boring but Critical” layer.

• Function: Multi-tenant isolation, secret management, and Micro-VM Sandboxing (e.g., E2B or Fly.io) to ensure agents can execute code without compromising the host network.

2. Strategic Views for Stakeholders

The Logical View: The Task Lifecycle

A request flows from Ingestion (Brief) → Planning (Decomposition) → Execution (Parallel Agentic Work) → Verification (AI-Critic) → Escalation (Human QA) → Delivery (Export). This flow ensures that the system is self-correcting. If an agent fails a task, the state is persisted, allowing a human to “unblock” the agent and resume the loop.

The Implementation View: The 2026 Stack

For an exit-ready architecture, CTOs should prioritize frameworks with strong “Durable Execution” and “Auditability.”

• Orchestration: LangGraph Enterprise. Why? It offers a managed control plane that records every transition in the state machine. For a PE firm, this is the “Black Box Recorder” that proves the value of the AI during due diligence.
• Backend: Python (FastAPI/PydanticAI) or TypeScript (NestJS).
• Storage: S3 for artifacts, Neon/Supabase for stateful data.
• Human Interface: Next.js 16 with real-time “Context-Streaming” so reviewers see exactly what the AI saw.

The Operating Model View: Hybrid Strategy

The architecture supports two distinct business strategies:

1. Efficiency Play (Internal): Focus on deploying the “Human Layer” to existing employees. Success is measured by Cycle Time Reduction and Output per FTE.
2. Scalability Play (External): Plug in a global marketplace of experts (The “Tendem Model”). Success is measured by Margin Expansion and Elastic Capacity.

3. The Agentic Maturity Model

PE firms and CTOs can use this 5-level model to benchmark portfolio companies and justify investment in AI infrastructure.

4. Why the Hybrid AI Workbench Architecture Wins at Exit

When a Private Equity firm prepares a company for exit in 2026, a “wrapper” is a liability, but an “Agentic Workbench” is a core asset.

1. Auditability: Because we use LangGraph Enterprise, every decision the AI made is traceable. A buyer can verify the accuracy and safety of the system’s history.
2. Portability: By modularizing the “Agent Mesh” (Layer 2) from the “Data Layer” (Layer 4), the company can swap models as they become cheaper or faster without rewriting the business logic.
3. Governance as Code: Security and compliance are not “add-ons”; they are baked into the state machine transitions, reflecting a mature approach to AI Governance & Risk Advisory.

Conclusion: The Path Forward with the Hybrid AI Workbench

The “Hybrid AI Workbench” is the blueprint for the next generation of service and software companies. It acknowledges that while AI can handle 90% of the volume, the final 10%—the human judgment—is where the real value (and the liability) lives.

CTOs: Your priority is building the “Durable State Machine”—a foundational piece of modern AI Architecture. Don’t build another chatbot; build a system that can pause, wait for a human, and resume without losing context.

PE Firms: Look for the “Uncertainty Gap.” The most valuable companies in your portfolio will be those that have successfully automated the “grunt work” of knowledge tasks while maintaining a high-fidelity human “Critic” layer.

Due Diligence Checklist for Private Equity Firms Evaluating Agentic AI

This is a framework for evaluating a portfolio company’s AI architecture based on the reference model. Concept aimed at successful AI-driven assets in 2026, with clear, affirmative answers to the questions.

Phase 1: Product & Market Fit (The Opportunity)

Problem Definition

• Is the AI solution targeting high-volume, high-variance knowledge work like market research, due diligence, compliance audits, or process verification?
• PE Goal: Ensure significant labor-arbitrage or massive scalability potential.

Addressable Market

• Is the target market large and currently reliant on manual labor or inefficient services?
• PE Goal: Verify the ‘Uncertainty Gap’ for value creation.

Use Case Clarity

• Are primary use cases: well-defined with clear inputs (briefs) and outputs (standardized deliverables)?

Phase 2: Technical Architecture (The Core Reference Model)

Orchestration Maturity (Layer 2)

• Does the architecture use a standard, exit-ready state machine framework like LangGraph Enterprise?
• Is the agent workflow modeled as a Durable State Machine, where a task can be paused, wait for human input, and resume without losing context?
• Is there a central ‘Critic Agent’ that audits all outputs before reaching the human layer?
• Red Flag: Is the solution a monolithic wrapper around a single API, or does it have specialized agents?

Platform & Security (Layer 5)

• Are all untrusted agents/tools executed in isolated, ephemeral micro-VMs (e.g., E2B, Fly.io)?
• Is there multi-tenant isolation with clear data access controls between clients or business units?
• Is there egress filtering to prevent agents from exfiltrating data or attacking external websites?

Data & Memory (Layer 4)

• Is there a full Provenance Chain tracing every data point in a deliverable back to its source URL and timestamp?
• Does the database (e.g., Postgres with pgvector) have Hybrid RAG capabilities for contextual memory?
• Is the data structure standardized for portfolio-wide learning or ‘Clean Room’ data sharing at Level 5 maturity?

Observability (Layer 5)

• Does the system provide comprehensive, trace-based evaluation (e.g., LangSmith, Arize Phoenix)?
• Does it also allow ‘replay’ of failing tasks to identify hallucinations or failed tool calls?

Phase 3: Human Capital & Operations (The Integration)

Integration of the Human Layer (Layer 3)

• Is the human review interface deeply integrated into the state machine, providing interactive full context (source URLs, AI ‘thoughts’) for efficient review?
• What is the escalation logic? Is it based on quantitative confidence scores?
• What is the strategy for the human layer: internal for 10x efficiency, or an external global marketplace for elastic scale?

Operational KPIs

• Can the company track Cost per Task, Cycle Time Reduction, and Output per FTE?
• What is the historical error rate? How has it changed with architectural improvements?
• What percentage of tasks require human touch?

Phase 4: Investment & Exit Strategy (Value Creation)

• Maturity Benchmarking: At what level is the company on the Agentic Maturity Model (1-5)?
• PE Goal: Identify clear milestones for investment to move from Level 3 to Level 4/5.
• Audit Readiness: Does the current architecture provide a full audit trail of every decision, tool call, and human action?
• PE Goal: Ensure the asset can withstand a buyer’s due diligence regarding AI safety and data provenance.
• Portability: Is the agent mesh (Layer 2) decoupled from the data layer (Layer 4) to allow model swapability for managing future costs?

Further Reading

• Automation Stack Starts With AI Architecture
• Build vs Buy AI Systems: 120k Decision Framework 2026
• TOGAF vs Zachman: Enterprise Architecture Guide

Written by Dr Hernani Costa | Powered by Core Ventures

Originally published at First AI Movers.

Technology is easy. Mapping it to P&L is hard. At First AI Movers, we don’t just write code; we build the ‘Executive Nervous System’ for EU SMEs.

Is your architecture creating technical debt or business equity?

👉 Get your AI Readiness Score (Free Company Assessment)

The Cat Breeds You Can No Longer Buy in the Netherlands

In a quiet apartment in Amsterdam, a Scottish Fold cat named Mochi sits on a windowsill, her signature folded ears giving her the wide-eyed, owl-like expression that made the breed an internet sensation. Mochi is legal — she was microchipped before the deadline. But as of January 1, 2026, no one in the Netherlands can buy, import, or breed another cat like her.

The Dutch government’s ban on Scottish Fold and Sphynx cats is one of the most aggressive animal welfare measures any country has taken against specific pet breeds, and it reflects a growing global consensus that the aesthetics humans find adorable in pets can mask serious suffering. Scottish Folds carry a genetic cartilage defect called feline osteochondrodysplasia (FOCD) — the same mutation that gives them their endearing folded ears also causes painful, progressive joint disease throughout their bodies. Sphynx cats, bred for their striking hairlessness, struggle to regulate body temperature and are prone to skin conditions.

The ban, announced by the Dutch Ministry of Agriculture, Fisheries, Food Security and Nature (LVVN), doesn’t require current owners to surrender their pets. But the rules are strict: existing cats must have been verifiably microchipped before January 1, and they can no longer appear in exhibitions or competitions. Violations carry a €1,500 fine.

“The aim of the ban is to improve animal welfare and prevent the breeding or sale of new cats with harmful physical traits. Folded-ear cats have a genetic cartilage defect which can lead to pain, stiff joints, limping, and in severe cases, paralysis.”
— Dutch Ministry of LVVN

What makes the Dutch move significant is that it isn’t happening in isolation. It’s part of a sweeping campaign called “Zo schattig dat het pijn doet” — “So cute that it hurts” — urging people to consider animal welfare before choosing a pet based on appearance. And the Netherlands isn’t alone. Belgium is already debating whether to follow suit, and the broader European Union is pushing legislation that could reshape pet ownership across the continent.

Europe’s Landmark Pet Welfare Law Takes Shape

The Netherlands’ breed ban is just one tile in a much larger mosaic. The European Union reached a provisional agreement on its first-ever comprehensive legislation on the welfare of dogs and cats — a landmark regulation that, once published in the Official Journal later in 2026, will fundamentally change how pets are bred, sold, and tracked across all member states.

The regulation’s centerpiece is mandatory microchipping for every dog and cat in the EU, linked to interoperable national databases. Sellers, breeders, and shelters will have four years to comply; private owners will have ten years for dogs and fifteen for cats. But the law goes far beyond identification. It introduces strict breeding restrictions: no mating between parents and offspring, grandparents and grandchildren, or siblings. It sets minimum and maximum breeding ages and limits how frequently animals can be bred. And critically, it bans breeding practices that produce exaggerated physical traits leading to significant health risks — a provision that could eventually affect brachycephalic breeds like French Bulldogs and Pugs across the continent.

The timing is no accident. A rabies case in Germany in early 2026 exposed the dangers of the current system. A dog imported from Russia through Latvia — one of a consignment of 24 animals (22 dogs and 2 cats) distributed by an animal charity — died on January 25, with rabies confirmed on February 10. Post-mortem examination revealed the dog was younger than declared, making it an illegal import despite having a microchip and vaccination records. The case triggered alarm across Europe: Belgium’s food safety agency contacted 50 owners of dogs adopted through the same Russian organization, and on March 18, Latvia’s Agriculture Minister formally called on the EU to impose a temporary ban on all commercial dog and cat imports from Russia and Belarus.

Germany, which had considered rabies eradicated since 1996, was shaken. The country’s Environmental Ministry issued an urgent recommendation for regular vaccination boosters for all dogs, cats, and ferrets — a reminder that in a world of cross-border pet adoption, diseases once considered vanquished can return with a single shipment.

Russia Prepares for Mandatory Pet Registration

Across the border, Russia is confronting its own pet governance challenges — from the opposite direction. While Europe tightens import controls, Russia is building the domestic infrastructure to track its pets for the first time.

A bill supported by the Duma’s Committee on Ecology in January 2026 would introduce mandatory registration and marking of all cats and dogs beginning September 1, 2026. Pet owners will submit their information to the state veterinary system (FGIS VetIS), and every animal must be physically identified — by collar, plastic tag, or subcutaneous microchip. Registration will be free, but owners bear the cost of marking, averaging 1,300 to 2,000 rubles (roughly $13–$20) in Moscow.

The urgency is clear from the numbers. Russia has an estimated 80 million domestic pets, but only about 30% are vaccinated — a figure that authorities say cannot improve without a unified federal tracking system. The law’s language also leaves room to expand beyond cats and dogs to ferrets, mini-pigs, and exotic pets in the future.

The vaccination gap is not just a Russian problem. It underscores a global reality: without knowing how many pets exist and who owns them, public health campaigns — from rabies prevention to parasite control — operate in the dark.

The United Kingdom’s War on Puppy Farms

Across the English Channel, the United Kingdom published its Animal Welfare Strategy on December 22, 2025 — described by Defra as the “biggest animal welfare reforms in a generation.” The strategy’s most emotionally charged provision targets puppy farming, the practice of keeping breeding dogs in appalling conditions, overbreeding them, and denying proper veterinary care.

The government will consult on reforming dog breeding practices to end puppy farming, with public consultations launched in early 2026. The RSPCA and Association of Cats and Dogs Homes have been lobbying for licensing of rescue centres and rehoming organisations, arguing that the unregulated rescue sector can inadvertently enable poor welfare. Additional measures include a proposed ban on electric shock collars and new requirements for pet sellers.

The strategy arrives as the RSPCA reports that more than 1,200 animals are currently housed in private boarding facilities at the charity’s expense because its own rescue centres are full — a sign that the demand for animal welfare services continues to outpace capacity.

Bolivia’s Street Dog Crisis Forces Action

Half a world away, the city of El Alto, Bolivia — perched at 4,000 meters above sea level on the Altiplano — is grappling with a crisis of a different kind. Of the approximately 270,000 dogs in the municipality, an estimated 100,000 roam the streets. Nationally, 8 out of every 10 dogs in Bolivia are “semi-domesticated” — they have an owner and a home, but spend much of their time unsupervised outdoors.

In March 2026, El Alto’s municipal government began socializing a draft law on responsible pet ownership with local institutions including the Forest and Environmental Preservation Police and the Departmental Health Service. The legislation would mandate pet registration and introduce sanctions to curb overpopulation, updating an existing municipal ordinance that authorities describe as inadequate.

The contrast with Europe is stark. While the Netherlands debates which cat breeds to ban and the EU designs continent-wide microchip databases, Bolivia is still trying to establish the most basic framework for knowing which dogs belong to whom. But the underlying challenge is the same everywhere: without registration, there is no accountability, and without accountability, animal welfare remains aspirational.

Parasites Don’t Respect Borders Either

In the United States, the threat isn’t regulatory but biological. The Companion Animal Parasite Council (CAPC) released its 2026 forecast in March, warning that vector-borne disease risk continues to expand geographically — and the organization’s forecasts have historically been 94% accurate.

Lyme disease, transmitted by blacklegged ticks, is spreading beyond its traditional strongholds in the Northeast and Upper Midwest into Ohio, Kentucky, West Virginia, Tennessee, and the Carolinas, with continued westward movement into the Northern Plains. Heartworm disease remains entrenched in the Southeast but is pushing northward along the Mississippi River corridor and the Atlantic coast, with emerging pockets in the Mountain West and Northern California. Ehrlichiosis risk is sustained across the South and Southwest, driven by the northward expansion of lone star ticks.

“Areas of higher canine Lyme risk often mirror areas where people contract Lyme disease, reinforcing the One Health connection between pets, people, and the environment.”
— Companion Animal Parasite Council

The CAPC’s message is blunt: year-round parasite prevention is no longer optional, regardless of geography. The old assumption that northern climates offered a winter reprieve from ticks and mosquitoes is increasingly obsolete. For the 83% of American pet owners who report that rising living expenses are a top source of stress, this creates a painful trade-off — preventive care costs money, but treating heartworm or Lyme disease costs far more.

Innovation on the Horizon

Not all the news is about threats and regulations. Elanco Animal Health received USDA approval in January 2026 for TruCan Ultra B (Oral), the first oral Bordetella vaccine formulated at a half-milliliter volume — a significant advance for dogs and owners who dread the traditional intranasal kennel cough vaccination. Built with Elanco’s PureFil technology to reduce adverse reactions, the vaccine launched in Q1 2026.

In Spain, the Purina PRO PLAN Calming Care Symposium held on March 13 brought together veterinary professionals to explore the gut-brain axis — the emerging science of how a pet’s digestive microbiome influences behavior, stress responses, and mental well-being. The symposium examined how specific probiotics can modulate canine anxiety, a topic that resonates as behavioral problems remain one of the leading reasons pets are surrendered to shelters.

And in China, where the pet market surpassed 300 billion yuan ($41 billion) in 2024 and is projected to reach 361 billion yuan by 2026, the Beijing International Pet Fair drew over 1,500 exhibitors across 150,000 square meters in March. The event featured the 7th Chinese Pet Preventive Medicine Forum, focusing on stress management, behavioral health, and gut health — themes that echo the European symposium and suggest a global convergence in how we think about pet wellness.

Meanwhile, Japan is quietly advancing pet disaster preparedness. On March 23, the All Japan Animal Professional Education Association signed an agreement with the city of Nobeoka in Miyazaki Prefecture on pet evacuation support during disasters — the latest step in a country that has been refining its approach since the 2011 tsunami left an estimated 30,000 animals in evacuation shelters. A separate survey by Ipet Insurance found that compliance with pet disaster preparedness guidelines remains low, prompting a complete overhaul of the company’s pet disaster resources in mid-March.

What It All Means for Pet Owners

The threads connecting these stories — from Amsterdam to El Alto, from the German-Russian border to the American Southeast — weave a single narrative. The era of casual, unregulated pet ownership is ending. Governments are building systems to track animals, restrict harmful breeding, and hold owners accountable. Diseases are shifting their geography, demanding year-round vigilance. And science is revealing that the bond between pets and their owners runs deeper than affection — it runs through the gut, the microbiome, and the nervous system.

For the estimated half-billion pet dogs and cats worldwide, 2026 may be remembered as the year the world stopped treating them as accessories and started treating them as what they are: members of the family who deserve the same thoughtfulness we bring to our own health, safety, and well-being.

I had 47 RSS feeds. Yes, 47. Plus three daily newsletters, GitHub Trending bookmarked, and a half-open Twitter/X tab “just to follow a few devs”. The result: two hours per week scrolling, a vague sense of being up to date, and discovering in production a breaking change in a Go lib that I should have caught six weeks earlier.

I changed my approach. Not because AI is magic — it isn’t — but because the problem wasn’t the volume of information. It was that I was reading without synthesizing, consuming without retaining. I restructured my tech watch around that observation, and AI became a tool in the process, not the core of it.

The problem with traditional tech watch

GitHub Trending is useful for discovering interesting projects on a Friday evening. It’s a terrible source for tracking an ecosystem’s evolution. What surfaces there is whatever got a lot of stars that week — usually a well-marketed side project, a README generator with a slick demo, or an “awesome-something” resource list. Meaningful changes in the language itself, silent deprecations, API migrations: none of that shows up.

Newsletters are the same story. Golang Weekly sends 15 links per week. I’d read three in full, skim the titles of the rest, and feel like I’d done my homework. In reality, I was just collecting open tabs. The signal-to-noise ratio is poor because these aggregators optimize for engagement, not for relevance to your specific stack and current projects.

The real problem: we consume information passively, never asking ourselves “what does this actually change for me, concretely, this week?”. Nobody asks that question for you — unless you build a system that does.

The method in practice

I didn’t delete everything. I sorted out what deserved to stay as a primary source, and defined what would go through an AI filter.

What I kept, unfiltered:

• The official Go release notes — read in full at every minor release
• The PostgreSQL changelog — especially the sections on indexes, query plans, and JSONB functions
• The Symfony blog — manually filtered, once a month
• Hacker News Weekly — the weekly digest, not the real-time feed

What goes through AI:

• Summarizing long changelogs (Go release notes sometimes run 3,000 words)
• Detecting potential breaking changes against my specific stack
• Targeted questions after reading an intriguing headline I don’t have time to dig into

The frequency is weekly, not daily. Daily is noise disguised as discipline. One structured session per week, with a concrete output (a markdown digest file), makes all the difference.

Prompts I actually use:

# After a Go release
"Here are the Go 1.25 release notes. My main work involves goroutines,
channels, sync/atomic, and the net/http package for REST APIs. Which changes
directly affect me? What deprecations should I plan for?
Give me a prioritized list, not a general summary."

# After a PostgreSQL update
"Here is the PostgreSQL 17.x changelog. My use cases: heavy JSONB queries,
partial indexes on tables with > 10M rows, pg_partman for partitioning.
What changes for me? Are there any behaviors that could alter existing
query plans?"

# For a one-off question
"In Go 1.24, what changed in garbage collector behavior compared to 1.22?
I'm specifically looking for the impact on high-allocation-frequency
applications (Kafka message processing)."

The difference from a Google search: I’m asking a question contextualized to my stack, not a generic one. The AI maps the raw changelog to my actual needs. That’s where the value is.

The automated workflow

After a few weeks of doing this manually, I wrote a bash script that runs as a cron job every Sunday morning. It fetches sources, builds a prompt, calls the Claude API, and generates a digest file in ~/veille/.

#!/bin/bash
# weekly-digest.sh — Automated tech watch
# Requires: ANTHROPIC_API_KEY as an environment variable
# Usage: chmod +x weekly-digest.sh && ./weekly-digest.sh

set -euo pipefail

DIGEST_DIR="$HOME/veille"
DATE=$(date +%Y-%m-%d)
OUTPUT="$DIGEST_DIR/digest-$DATE.md"
mkdir -p "$DIGEST_DIR"

echo "=== Tech watch digest — $DATE ===" > "$OUTPUT"
echo "" >> "$OUTPUT"

# --- Fetch Go release notes (official releases page) ---
echo "[*] Fetching Go release notes..."
GO_RELEASES=$(curl -s "https://go.dev/doc/devel/release" 
    | grep -oP '(?<=<h2 id=")[^"]+' 
    | head -5)

# Fetch the text content of the latest release note
LATEST_GO=$(echo "$GO_RELEASES" | head -1)
GO_CONTENT=$(curl -s "https://go.dev/doc/go${LATEST_GO#go}" 2>/dev/null 
    || curl -s "https://tip.golang.org/doc/go${LATEST_GO#go}" 2>/dev/null 
    || echo "Content unavailable via curl — see https://go.dev/doc/devel/release")

# --- Fetch PostgreSQL changelog ---
echo "[*] Fetching PostgreSQL changelog..."
PG_CONTENT=$(curl -s "https://www.postgresql.org/docs/release/" 
    | grep -A 2 'class="title"' 
    | grep -oP '(?<=>)[^<]+' 
    | head -20 
    | tr 'n' ' ')

# --- Build the prompt ---
PROMPT="You are a tech watch assistant for a senior Go/PostgreSQL/PHP developer.

Here is the information retrieved this week:

## Go — Recent releases
$GO_RELEASES

## PostgreSQL — Recent versions
$PG_CONTENT

My main stack:
- Go: REST APIs, goroutines/channels, sync/atomic, net/http, kafka-go
- PostgreSQL: JSONB, partial indexes, partitioning, pg_partman
- PHP/Symfony: secondary APIs, batch processing

Generate a structured weekly digest with:
1. Go changes that directly affect me (if a recent release exists)
2. PostgreSQL changes to watch
3. Watch points / potential breaking changes
4. What I can safely ignore this week

Format: Markdown. Be concise and prioritized. If you don't have enough info on a specific version, say so clearly rather than making things up."

# --- Anthropic API call ---
echo "[*] Calling Claude API..."
RESPONSE=$(curl -s https://api.anthropic.com/v1/messages 
    -H "x-api-key: $ANTHROPIC_API_KEY" 
    -H "anthropic-version: 2023-06-01" 
    -H "content-type: application/json" 
    -d "{
        "model": "claude-opus-4-6",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": $(echo "$PROMPT" | python3 -c 'import json,sys; print(json.dumps(sys.stdin.read()))')
            }
        ]
    }")

# Extract the response text
DIGEST_CONTENT=$(echo "$RESPONSE" | python3 -c "
import json, sys
data = json.load(sys.stdin)
if 'content' in data and len(data['content']) > 0:
    print(data['content'][0]['text'])
else:
    print('API error:', data.get('error', {}).get('message', 'Unexpected response'))
    print('Raw:', json.dumps(data, indent=2))
")

# --- Write the digest ---
echo "$DIGEST_CONTENT" >> "$OUTPUT"
echo "" >> "$OUTPUT"
echo "---" >> "$OUTPUT"
echo "*Generated on $DATE — verify primary sources before taking action.*" >> "$OUTPUT"

echo "[OK] Digest written to $OUTPUT"

To automate it every Sunday at 8am:

# crontab -e
0 8 * * 0 ANTHROPIC_API_KEY=your_key_here /path/to/weekly-digest.sh >> /var/log/veille.log 2>&1

Note: I put the API key directly in the cron rather than in a .env to avoid sourcing a file in a cron context. On a shared server, use a credentials file with proper permissions (chmod 600) instead.

The digest opens automatically in my editor on Sunday morning via another cron line. Ten minutes of focused reading instead of two hours of scrolling.

What it actually changes

Three real examples since I started using this workflow:

sync/atomic in Go: the digest flagged the changes in the sync/atomic package early enough — the introduction of generic types (atomic.Int64, atomic.Pointer[T]). I had code using the low-level functions (atomic.AddInt64) in a metrics counter. I was able to plan the migration calmly, before it became invisible technical debt.

PostgreSQL JSONB: the query planner changes around JSONB in PG16/17 have implications for indexes. Without the digest, I’d probably have discovered the changed behavior reading a confusing EXPLAIN ANALYZE on a Tuesday night at 11pm. With the digest, I read the release note and adjusted my indexes ahead of time.

The main gain isn’t detection: it’s the mindset. I no longer read changelogs in anxious mode — “did I miss something important?” I have a process. That changes your relationship with information.

The real limitations

It would be dishonest not to address these. AI in this workflow has genuine blind spots.

Hallucinations on version numbers. This is the number one problem. Claude — like all LLMs — can invent a version number, conflate two releases, or assert that a feature has been available since Go 1.21 when it actually landed in 1.23. The rule: the digest is a starting point, never a source of truth. Every point flagged as important must be verified in the official release note before acting on it. I added an explicit instruction in the prompt (“if you don’t have enough info on a specific version, say so clearly”) — it helps, but doesn’t eliminate the risk.

Confirmation bias. When I ask “what affects my Go stack”, the AI tends to tell me what it thinks I want to hear. If I work heavily with channels, it will over-index on concurrency changes. It won’t spontaneously tell me that the real novelty in a release is an improvement to the profiling tooling — if I haven’t mentioned that I care about it. The prompt needs regular calibration to avoid building an echo chamber.

What it doesn’t replace. A GopherCon conference is three days of hearing people dealing with problems at a scale I haven’t hit yet, and understanding how they solved them. No digest replaces that. A senior colleague saying “watch out, I tried that approach in 2023 and it bites” — that either. And reading a post-mortem in full, with the timeline, the decisions made under pressure, the mistakes owned up to: that’s a form of knowledge transfer that doesn’t survive a summary.

Cost and dependency. The Anthropic API costs money. Not much for a weekly digest (a few cents per call with claude-opus-4-6), but it’s an external service with its own availability and pricing uncertainties. And if the API changes, the script breaks.

The risk of no longer really reading. This is the most insidious one. Delegating synthesis means risking delegating understanding as well. If I never read a release note in full again, I’ll lose the eye for detail, the ability to spot what matters on my own. The digest must stay an intake filter, not a substitute for reading.

What it replaces, and what it doesn’t

This workflow replaces reading 3,000-word raw changelogs when I’m looking for two specific pieces of information. It also replaces manually synthesizing ten articles that all say the same thing in different words. It freed me from the obligation to read everything for fear of missing something.

It doesn’t replace curiosity. If I don’t ask “what changed in Go’s memory management over the last two versions”, no script will ask it for me. AI executes a process — it doesn’t generate one.

It doesn’t replace experimentation. Truly understanding a change in the Go scheduler means writing a benchmark, observing the behavior — not reading a summary.

It doesn’t replace conversations between developers. The most useful tech watch I did this year was a thirty-minute conversation with another dev who had migrated a large PostgreSQL database to native partitioning. No LLM could have given me the same nuance on what went wrong and why.

The real meta-observation: tech watch has always been a question of method. The best developers I know never had 47 RSS feeds — they had three carefully chosen sources they actually read. AI hasn’t changed that fundamental principle. It just made it more visible by forcing me to formalize what I wanted to learn, for whom, and at what frequency. That might be the most lasting contribution.

MiniStack is a free, open-source, MIT-licensed drop-in replacement for LocalStack — 21 AWS services on a single port, no account, no license key, no telemetry.

v1.0.4 is out today. This post covers everything that landed across the v1.0.2–v1.0.4 wave: the big features, the architectural decisions behind them, and the fixes that got us to a clean 379-test run.

docker run -p 4566:4566 nahuelnucera/ministack

Why this exists

LocalStack moved its core services behind a paid plan. If you were using LocalStack Community for local dev and CI/CD, you now hit a paywall for S3, SQS, Lambda, and most things that matter.

MiniStack covers the same surface — and goes further in a few areas — at $0, MIT licensed, forever. The full comparison is on ministack.org, but the short version: same developer experience, 150 MB image vs ~1 GB, ~30 MB RAM at idle vs ~500 MB, ~2 s startup vs 15–30 s.

What shipped in v1.0.2–v1.0.4

API Gateway HTTP API v2 — full control plane + data plane

This was the biggest missing piece. v1.0.2 delivered the complete API Gateway v2 implementation.

Control plane covers the full resource tree:

• APIs: CreateApi, GetApi, GetApis, UpdateApi, DeleteApi
• Routes: full CRUD, including {param} path parameter placeholders and {proxy+} greedy matching
• Integrations: AWS_PROXY (Lambda) and HTTP_PROXY (arbitrary HTTP backends)
• Stages, Deployments, Authorizers (JWT + Lambda), Tags

Data plane is the part most emulators skip. In MiniStack, execute-api requests are dispatched by host header — {apiId}.execute-api.localhost — before normal service routing. That means your actual API calls hit the right Lambda function with a proper payload format 2.0 envelope:

import boto3

apigw = boto3.client("apigatewayv2", endpoint_url="http://localhost:4566",
                     aws_access_key_id="test", aws_secret_access_key="test",
                     region_name="us-east-1")

api = apigw.create_api(Name="my-api", ProtocolType="HTTP")
api_id = api["ApiId"]

apigw.create_route(ApiId=api_id, RouteKey="GET /hello")
apigw.create_integration(
    ApiId=api_id,
    IntegrationType="AWS_PROXY",
    IntegrationUri=f"arn:aws:lambda:us-east-1:000000000000:function:my-func",
    PayloadFormatVersion="2.0",
)

import requests
resp = requests.get(f"http://{api_id}.execute-api.localhost:4566/hello")
print(resp.json())

Route matching supports path parameters and {proxy+} greedy segments. There was a subtle bug in the initial implementation: re.escape was applied before {param} substitution, which meant every parameterised route silently fell through to a 404. Fixed in v1.0.2.

Authorizers ship with full CRUD — JWT and Lambda authorizer types, with identitySource stored and returned as an array of strings matching the AWS spec (was incorrectly a single string in the initial cut).

Lambda warm/cold start worker pool

Prior to v1.0.2, every Lambda invocation spawned a fresh subprocess. That’s fine for correctness but misses a whole class of bugs that only appear when your handler module is imported once and invoked repeatedly.

core/lambda_runtime.py now maintains a persistent Python subprocess per function. The handler module is imported on first invocation (cold start), and subsequent calls reuse the warm worker without re-importing. Workers respawn automatically on crash.

This matters for three reasons:

1. Correctness — module-level state (caches, connection pools, counters) behaves the same as in real Lambda
2. Speed — warm invocations are significantly faster in CI
3. Bug surface — you’ll catch issues with global state that a fresh-subprocess model would mask

import boto3

_client = None

def handler(event, context):
    global _client
    if _client is None:
        _client = boto3.client("s3", endpoint_url="http://localhost:4566",
                               aws_access_key_id="test", aws_secret_access_key="test",
                               region_name="us-east-1")
    return {"buckets": [b["Name"] for b in _client.list_buckets()["Buckets"]]}

In MiniStack, that _client initialization happens exactly once per function, just like AWS.

SNS → SQS fanout and SNS → Lambda dispatch

sqs protocol subscriptions now deliver messages directly to SQS queues with the standard SNS JSON notification envelope. lambda protocol subscriptions invoke the Lambda function via _execute_function() with a Records[].Sns event structure. Both were stubs in v1.0.1 — SNS→SQS was wired in v1.0.2, SNS→Lambda was a no-op that got fixed in the same release.

sns = client("sns")
sqs = client("sqs")

topic = sns.create_topic(Name="events")["TopicArn"]
queue = sqs.create_queue(QueueName="consumer")
queue_url = queue["QueueUrl"]
queue_arn = sqs.get_queue_attributes(
    QueueUrl=queue_url, AttributeNames=["QueueArn"]
)["Attributes"]["QueueArn"]

sns.subscribe(TopicArn=topic, Protocol="sqs", Endpoint=queue_arn)
sns.publish(TopicArn=topic, Message="hello fanout")

msgs = sqs.receive_message(QueueUrl=queue_url)
body = json.loads(msgs["Messages"][0]["Body"])
print(body["Message"])  # hello fanout

Fanout is synchronous within the same process — consistent with how LocalStack handles it and good enough for unit/integration testing.

SQS → Lambda event source mapping

Full ESM lifecycle: CreateEventSourceMapping, DeleteEventSourceMapping, GetEventSourceMapping, ListEventSourceMappings, UpdateEventSourceMapping.

A background poller picks up messages from the configured SQS queue and delivers them to the target Lambda as batched events. Batch size and enabled state are configurable.

lam = client("lambda")
sqs = client("sqs")

queue_url = sqs.create_queue(QueueName="trigger-queue")["QueueUrl"]
queue_arn = sqs.get_queue_attributes(
    QueueUrl=queue_url, AttributeNames=["QueueArn"]
)["Attributes"]["QueueArn"]

lam.create_event_source_mapping(
    EventSourceArn=queue_arn,
    FunctionName="my-processor",
    BatchSize=10,
    Enabled=True,
)

sqs.send_message(QueueUrl=queue_url, MessageBody=json.dumps({"event": "order_placed"}))

State persistence

PERSIST_STATE=1 enables atomic state snapshots to disk. Writes go to a temp file first, then rename — so a crash mid-write doesn’t corrupt the saved state. STATE_DIR controls where (default /tmp/ministack-state).

API Gateway state is fully persisted across container restarts. The persistence framework is designed so other services can adopt the same get_state() / load_persisted_state() pattern incrementally.

The reset endpoint (POST /_ministack/reset) clears in-memory state and, when PERSIST_STATE=1, also deletes STATE_DIR/*.json and S3_DATA_DIR contents — so a restart doesn’t reload stale state. Also used in the test suite as a session-scoped autouse fixture to keep tests idempotent across repeated runs.

DynamoDB TTL enforcement

TTL was previously stored — TimeToLiveSpecification accepted and returned without error — but never acted on. Items just sat there forever. A background daemon thread (dynamodb-ttl-reaper) now scans all tables every 60 seconds and deletes items whose TTL attribute value is ≤ current epoch time.

Lambda Function URLs

Full CRUD: CreateFunctionUrlConfig, GetFunctionUrlConfig, UpdateFunctionUrlConfig, DeleteFunctionUrlConfig, ListFunctionUrlConfigs. State persisted in _function_urls. Was a 404 stub before.

SQS queue URL portability (v1.0.4)

QueueUrl values now read MINISTACK_HOST and GATEWAY_PORT env vars instead of hardcoding localhost:4566. This was causing silent failures in CI environments where MiniStack runs as a service container with a network alias.

services:
  ministack:
    image: nahuelnucera/ministack
    environment:
      MINISTACK_HOST: ministack
      GATEWAY_PORT: 4566
  app:
    environment:
      AWS_ENDPOINT_URL: http://ministack:4566

Before this fix, queue URLs returned http://localhost:4566/... regardless of configuration, and any SQS operation using that URL from another container would fail.

Bug fixes worth calling out

Several of these look fine in smoke tests but break real workloads.

execute-api credential scope misrouted to lambda — In core/router.py, the credential scope for execute-api requests was mapped to lambda instead of apigateway. Any data plane request was dispatched to the Lambda handler instead of the API Gateway data plane. Fixed in v1.0.2.

routeKey always "$default" in Lambda proxy events — The routeKey field was hardcoded to "$default" regardless of which route was matched. If your handler branched on event["routeKey"] — common in single-function routers — every request hit the default branch. Fixed to reflect the actual matched route key (e.g. "GET /users/{id}").

identitySource wrong type on Authorizers — Stored and returned as a plain string instead of an array of strings. boto3 raised a shape validation error on the response. Now returns ["$request.header.Authorization"] as the AWS spec requires.

DeleteFunctionUrlConfig returning {} body on 204 — boto3 expects an empty body on 204. The non-empty body caused a RemoteDisconnected exception. Fixed to return a true empty 204.

/_ministack/reset not cleaning disk — When PERSIST_STATE=1, reset cleared in-memory state but left STATE_DIR/*.json and S3_DATA_DIR intact. On the next restart, old state was reloaded. Fixed to delete persisted files as well.

Test idempotency — Tests with hardcoded resource names failed on a second run because the resources already existed. Fixed by wiring POST /_ministack/reset into a session-scoped autouse fixture in conftest.py.

Test suite: 54 → 379

v1.0.1 shipped with 54 integration tests. v1.0.4 has 379, all passing against both the in-process server and the Docker image.

The growth came from:

• 10 new tests covering previously untested paths: health endpoint, STS GetSessionToken, DynamoDB TTL, Lambda warm start, API Gateway execute-api Lambda proxy, $default catch-all, path parameter matching, 404 on missing route, EventBridge → Lambda dispatch
• 25 new tests for operations added post-v1.0.1: Kinesis shard split/merge, SSM label/tag operations, CloudWatch Logs retention/subscription/metric filters/Insights, CloudWatch composite alarms, EventBridge archives/permissions, DynamoDB UpdateTable, S3 versioning/encryption/lifecycle/CORS/ACL, Athena workgroup and batch operations
• Full coverage of all v1.0.2 features: API Gateway control + data plane, SNS→SQS fanout, SQS→Lambda ESM, Lambda warm start, persistence, reset

Tests run against the Docker image — no mocking, no monkeypatching, real boto3 calls over the wire.

What’s still on the roadmap

• API Gateway REST API (v1)
• Cognito — user pools, sign-up/sign-in
• Route53 — hosted zones, record sets
• ACM — certificate management
• Firehose
• Virtual-hosted style S3 (bucket.localhost:4566 routing)

Getting started

docker run -p 4566:4566 nahuelnucera/ministack

# With persistence and Redis sidecar
git clone https://github.com/Nahuel990/ministack
cd ministack
docker compose up -d

curl http://localhost:4566/_localstack/health

Works with boto3, AWS CLI, Terraform, CDK, Pulumi. Point endpoint_url at http://localhost:4566, credentials test/test, and you’re done.

GitHub: github.com/Nahuel990/ministack
Docker Hub: hub.docker.com/r/nahuelnucera/ministack
Site: ministack.org

Stars, issues, and PRs welcome. Each service is a single self-contained Python file — adding a new one is straightforward.

If you’re running a homelab, you’ve probably already got speech-to-text somewhere in your stack.

Maybe you use it for Home Assistant voice commands. Or local LLM integrations. Or just transcribing meeting recordings.

Here’s something you might not have considered: you can use that same transcription server as a keyboard on your iPhone.

The 3 Commands

git clone https://github.com/omachala/diction
cd diction
docker compose up -d

That’s the server running. Now install Diction on your iPhone, point it at your server URL, and you have a voice keyboard backed by your own speech-to-text instance.

What’s Actually Running

The Docker Compose setup spins up two services:

services:
  gateway:
    image: ghcr.io/omachala/diction-gateway:latest
    ports:
      - "8080:8080"

  whisper-small:
    image: fedirz/faster-whisper-server:latest-cpu
    environment:
      WHISPER__MODEL: Systran/faster-whisper-small
      WHISPER__INFERENCE_DEVICE: cpu

whisper-small: the transcription engine — runs open-source speech-to-text via a REST API. CPU works fine for real-time dictation.

gateway: Diction’s open-source Go gateway. Handles communication between the iOS app and the transcription backend — routing, streaming, audio format conversion.

The gateway exposes port 8080. That’s the URL you put into the Diction app.

Making It Accessible From Your Phone

Your phone needs to reach your server. A few options:

Tailscale (easiest): Install Tailscale on both your server and iPhone. You get a private IP accessible from anywhere. No port forwarding, no firewall rules.

http://100.x.x.x:8080

Reverse proxy (for existing homelabbers): If you’re already running Caddy, nginx, or Traefik, add a route to port 8080. Get a subdomain, TLS, the whole thing.

https://diction.yourdomain.com

Direct LAN (simplest for home-only use): Just use your server’s local IP. Works on home WiFi, not outside.

http://192.168.1.100:8080

Configuring Diction

Open the Diction app → Settings → Backend → Self-Hosted.

Enter your server URL. The app tests the connection and shows a green indicator when it’s reachable.

That’s it. The keyboard is now connected to your server.

Choosing a Model

You can swap the transcription model by changing the WHISPER__MODEL environment variable on the speech-to-text container. The model downloads automatically on first use.

For a home server or NAS, the small model is a solid starting point. If you have a GPU, the large model gives you transcription quality that rivals most paid services.

Swap the model in your compose file:

  whisper-small:
    image: fedirz/faster-whisper-server:latest-cpu
    environment:
      WHISPER__MODEL: Systran/faster-whisper-medium
      WHISPER__INFERENCE_DEVICE: cpu

Or add multiple model containers and set DEFAULT_MODEL on the gateway to pick which one handles requests.

Running on Lower-Power Hardware

The small model runs well on modern CPUs. For lower-power devices like a NAS or a Raspberry Pi, try the tiny model variant — it uses less RAM (~350MB) and responds faster, at the cost of some accuracy.

For real-time keyboard use, aim for sub-3 second latency. The small model on a modern CPU or the tiny model on lower-power hardware gets you there.

The App

Diction is an iOS voice keyboard. Download it, enable it in Settings → General → Keyboard → Keyboards, grant Full Access, and connect to your server.

Self-hosted mode is free with no word limits or restrictions. There’s also a cloud option (Diction One) for users who don’t want to run their own server.

Download on the App Store · diction.one · github.com/omachala/diction