Imagine you’re a lawyer presenting to the court of world opinion. You’ve stated your principles (all people have rights, government must protect them). Now you must prove your case: that King George III has systematically violated these principles. The Declaration lists 27 specific charges. Today we’ll examine how these grievances justified revolution.
Engage: Building the Case
Explore: The Pattern of Tyranny
Jefferson didn’t randomly list complaints. He organized them to show escalating abuse:
Military oppression (using force against civilians)
Economic warfare (destroying colonial prosperity)
Each grievance connected to a fundamental right. This wasn’t about tea taxes—it was about systematic destruction of self-government.
Explain: Key Grievances That Broke the Bonds
“He has refused his Assent to Laws, the most wholesome and necessary for the public good.” Colonial legislatures passed laws; the king vetoed them. Colonies couldn’t address local problems without royal permission from 3,000 miles away.
“He has dissolved Representative Houses repeatedly.” When colonial assemblies resisted, the king simply shut them down. Imagine Congress being dissolved whenever it disagreed with the President.
“He has kept among us, in times of peace, Standing Armies without the Consent of our legislatures.” British troops occupied Boston. Soldiers lived in civilian homes. This violated the English tradition that militaries shouldn’t police civilians.
“For imposing Taxes on us without our Consent.” Not just the famous Stamp Act and tea tax—Parliament claimed unlimited power to tax colonists who had no vote in Parliament.
“For depriving us in many cases, of the benefits of Trial by Jury.” The British moved trials to admiralty courts (no jury) or transported Americans to England for trial, away from witnesses and supporters.
The most emotional charge: “He has excited domestic insurrections amongst us, and has endeavoured to bring on the inhabitants of our frontiers, the merciless Indian Savages.”Lord Dunmore‘s 1775 proclamation promised freedom to enslaved people who joined the British, and British agents encouraged Native American raids on frontier settlements.
Elaborate: We Tried Everything Else
The Declaration emphasizes that independence was a last resort:
“In every stage of these Oppressions We have Petitioned for Redress in the most humble terms: Our repeated Petitions have been answered only by repeated injury.”
They sent the Olive Branch Petition (1775), pleading for reconciliation. King George refused to read it and declared the colonies in rebellion. They appealed to Parliament. Parliament passed harsher laws. They appealed to the British people. The British people elected more hardline members to Parliament.
“We have warned them from time to time… They too have been deaf to the voice of justice.”
Evaluate: The Point of No Return
The conclusion was inevitable: “We, therefore… do, in the Name, and by Authority of the good People of these Colonies, solemnly publish and declare, That these United Colonies are, and of Right ought to be Free and Independent States.”
The final line carries enormous weight: “We mutually pledge to each other our Lives, our Fortunes and our sacred Honor.”
John Hancock signed large enough for King George to read without spectacles. Benjamin Franklin quipped: “We must all hang together, or assuredly we shall all hang separately.” These men knew the penalty for treason.
Key Vocabulary
Redress: Remedy or compensation for a wrong or grievance
Assent: Official agreement or approval, especially royal approval of colonial laws
Standing Army: Professional soldiers maintained in peacetime, seen as a threat to liberty
Domestic Insurrections: Rebellions within the country, referring to British attempts to incite enslaved people
Think About It
The Declaration never uses the word “rebellion” or “revolution.” Instead, it frames independence as defending existing rights against British violations. Why might this framing matter for gaining domestic and international support?
Notice what Congress removed and consider why. The editing process reveals the political compromises necessary to achieve unanimous support for independence.
Tomorrow: We’ll examine how the new states created their first constitutions, experimenting with republican government while fighting for survival.
On July 4, 1776, fifty-six men signed their names to a document that could have been their death warrant. British law defined treason clearly: challenging the king’s authority meant hanging. Yet they signed anyway. What words were worth dying for?
Explore: The Structure of Revolution
The Declaration of Independence isn’t just a breakup letter to King George III—it’s a carefully constructed legal argument. Jefferson and the Continental Congress knew they needed to justify revolution not just to Britain, but to the world and to posterity. The document follows the structure of a logical proof:
Universal principles (what all people deserve)
Specific violations (how Britain broke these principles)
Previous attempts at reconciliation (proving reasonableness)
The necessity of separation (the logical conclusion)
Today we’ll focus on the preamble and philosophical foundation—the ideas that made this document revolutionary.
Explain: The Immortal Words
“We hold these truths to be self-evident, that all men are created equal, that they are endowed by their Creator with certain unalienable Rights, that among these are Life, Liberty and the pursuit of Happiness.”
Let’s unpack this profound sentence:
“self-evident” – These aren’t opinions or cultural preferences. They’re universal truths that any reasoning person should recognize.
“all men are created equal” – In an age of kings, nobles, and rigid social hierarchy, this was radical. No divine right of kings, no hereditary superiority.
“endowed by their Creator” – Rights come from God or nature, not from government. Government can’t grant what it didn’t create.
“unalienable” – These rights can’t be surrendered or taken away. They’re permanently attached to being human.
Jefferson continues: “That to secure these rights, Governments are instituted among Men, deriving their just powers from the consent of the governed.”
This flips traditional authority upside down. Government doesn’t grant rights—it exists to protect rights we already have. Power flows up from the people, not down from the ruler.
Elaborate: The Right of Revolution
The most radical claim comes next: “That whenever any Form of Government becomes destructive of these ends, it is the Right of the People to alter or to abolish it.”
This wasn’t just about America and Britain. Jefferson articulated a universal principle: when government fails its fundamental purpose, the people may rightfully replace it. This idea would inspire revolutions from France to Latin America to modern democracy movements.
But the founders weren’t promoting casual rebellion. They added: “Governments long established should not be changed for light and transient causes.” Revolution is a last resort, justified only by systematic oppression, not temporary disagreements.
Evaluate: The Contradiction and the Promise
The man who wrote “all men are created equal” owned 175 enslaved people. This horrific contradiction would haunt America from its founding. Frederick Douglass would later ask: “Are the great principles of political freedom and natural justice, embodied in that Declaration of Independence, extended to us?”
Yet the principles themselves transcended their flawed authors. Abraham Lincoln called them “a rebuke and a stumbling-block to tyranny and oppression.” Martin Luther King Jr. called the Declaration a “promissory note” that America must honor for all its citizens.
Key Vocabulary
Self-evident: Obvious truths requiring no proof or explanation
Unalienable Rights: Fundamental rights that cannot be taken away or given up
Consent of the Governed: The idea that government’s legitimacy comes from the people’s agreement
Pursuit of Happiness: The right to seek fulfillment and well-being as one defines it
Think About It
Jefferson originally wrote “life, liberty, and property” (following Locke) but changed it to “pursuit of happiness.” Why might this change matter? What’s the difference between guaranteeing property versus guaranteeing the pursuit of happiness?
Last week I left you with a nail-biter. I ran a sneaky wifi network near a weird marathon in 2018 and I captured close to 200 devices. I reproduced the experiment this fall- how’d it go in 2025? Terrible in some regards, but awesome in terms of prototyping acceleration. An experiment that took 2 months in 2018 took me 4 days in 2025.
Time lapse of runners
The Bad
In the 2025 experiment, I caught a grand total of 18 devices.
Does this mean mobile phones are more secure? Was it the exact same experiment? No!
Low Participant Turnout: My Wifi Hotspot was active starting at 7 am. The marathon was scheduled to start at 8 am. We didn’t see a single runner till ~9:15 am. When runners did start arriving, the quantity of runners was limited compared to past years. The 2018 marathon spanned two days. The race was only one day this year. The participant cohort of runners was significantly smaller than in years past.
Bad SSID choices: This attack depends upon your ability to anticipate a wifi ssid that your targets have an affinity for. The wifi SSID i used in 2018 wasn’t going to work because it has been deprecated. I went with “Starbucks WiFi” initially, but this only caught 2 devices. The lack of “Starbucks WiFi” tuned devices is an interesting indicator of how times have changed. It used to be that mobile phone owners needed to attach to wifi to use email/browse the web with their phones. This was because cellular networks did not have unlimited data, and so you either ran out of data for the month or you were hit with a large cellphone bill if you used cellular for data. People used to go to coffee shops to “work” on their phones and laptops. Now you’re really there to socialize or caffinate. I also wonder if Starbucks’ popularity has declined. In the last 10 years, I’ve only drank Starbucks out of necessity.
So after a couple of hours of watching only 2 attaches, I yielded to temptation and changed the SSID to “xfinitywifi.” The xfinitywifi ssid is a controversial wifi network vended by Comcast, exclusive to comcast customers.
You can use wigle.net to see the most popular active SSIDs:
Changing to use xfinitywifi felt like desperation! Comcast does not have much presence in Snoqualmie valley. I reasoned that most of the runners were probably coming from cities where Comcast is dominant- e.g. Bellevue, Issaquah and Redmond. I managed to catch 16 more devices over the next 4 hours. The count was so small I didn’t bother to keep my logs. But here are some screenshots to give you a feel for what I experienced:
Raspberry Pi with AWUS036ACH WiFi adapter & home built dual yagisPaperwhite displayCustom status monitor
This experiment agitated me greatly. I know there are still problems related to wifi offloading- but I only caught 18 devices. I didn’t spend enough time researching SSIDs and the end result was low attaches.
Despite my grumpiness about the data, this experiment was a major success.
Did you notice the external Wifi Adapter above? How about the nice Paperwhite display presenting status of the device. My monitoring script was far more sophisticated than a tail of a hostapd logs. I didn’t have to write this code or fiddle with hostapd configurations or nftables rules. I didn’t have to find the right kernel headers and compile wifi drivers. I didn’t have to flex my terrible design skills. I knew the features I wanted and I gave my agents direction on how to deploy the features.
I was able to successfully produce an IoT prototype with complex hardware dependencies in 4 days.
The Good:
I implemented a working prototype of a custom wifi hotspot with a paperwhite display, an external wifi adapter & a Yagi wifi antenna in 4 days.
Methodology
Claude Code & Pre-prompting strategies
I leveraged Claude code for most of my work. I created a working directory invoked Claude with a 1,500 line pre-prompt for requirements analysis and planning. This pre-prompt produced ansible playbooks that take advantage of my Firmware Development caching containers. The pre-prompt addresses topics related to Requirement Exploration, Architecture Safety, Known Good Deployment Patterns, Domain Specific Knowledge and Documentation & Maintenance. I’ve been iterating on this prompt for about 6 weeks through applications on about 5 other projects. I constructed a separate pre-prompt of 166 lines that handles Deploying code, Code analysis, system access, frameworks for deploying code & systematic troubleshooting and refactoring the code to address discovered defects.
Development Loop
The normal lifecycle of developing a reliable working prototype seems to take about 3-4 build cycles.
My agent would serially perform the following operations during the build process:
Initiate a build
Discover defects during build process
Troubleshoot them on the recipient system
Make corrections to the original build playbooks
Resume the build at the corrected defect
Complete a working build.
If the build experienced errors, I waited to get a complete build and then started again on fresh recipient image. I kept seeing improvements until the build process ran reliably without errors.
Throttling
My biggest challenge was rate limiting:
My agents hit my 5 hour Anthropic token limit on the $20 plan in about 2 hours. During this 4 day period, I scheduled my day around throttling limits. I tried to make sure that some building happened while I slept. Two days before the marathon, I upgraded to the $200 plan. My iOS screen time report was 1 hour during that week.
I didn’t have to write any code to make this project work. That’s not to suggest that anybody could do this experiment. I was successful because I knew exactly what software libraries I wanted to see deployed and how I wanted them tuned. I regularly had to intervene when the agents proposed bad plans. But I’m now approaching a point where my single board computer development processes are automated. It felt like having a mildly competent apprentice.
Over the last few years, I’ve been able to build a range of Raspberry Pi Prototypes. All of them were a labor of large effort. My build process made prototyping faster, but it still took me several months to work out the details of various project:
An rPi with a self hosted Ghost Blog & Planka Kanban board + cloudflared tunnels. This enables me to track my progress on personal goals and projects without paying money to Amazon or Trello.
Making reproducible builds was expensive and typically took 2-3 months. I’d steal spare time on evenings or weekends to work on projects. The greatest costs come from the testing & validation needed to create durable, reproducible firmware images. With a combination of tasteful pre-prompts, custom agents & an automated build process I can turn around reproducible firmware builds in less than a week.
1. Software & Hardware Testing Houses
You need repeatable, cost-effective environments to validate new software and hardware under real-world conditions, but setting up and tearing down test rigs is slow, inconsistent, and prone to configuration drift.
2. Managed Security Service Providers (MSSPs) You need deployable, trusted network nodes inside customer environments for monitoring, detection, and incident response — but sourcing, configuring, and reproducing reliable hardware platforms across dozens of clients eats up valuable engineering time.
3. IoT Manufacturers
You want to prove out your next device concept quickly, with working prototypes that demonstrate connectivity, edge processing, and security — but your in-house teams are bottle-necked by long development cycles and unpredictable integration issues.
4. Agricultural & Rural Networking Providers
You need rugged, affordable devices to extend connectivity into fields, barns, and remote communities — but commercial gear is overpriced, hard to customize, and not designed for rapid prototyping or deployment in challenging environments.
5. Telecom & Network Operators You need cost-effective, rapidly deployable edge devices for monitoring network performance, testing bandwidth in rural or urban environments, or validating new customer premises equipment—but traditional hardware procurement cycles are too slow and expensive.
6. Smart City & Infrastructure Providers You’re deploying IoT devices to manage traffic lights, utilities, or environmental sensors across a city, but you need quick, low-cost prototypes to validate integrations before scaling to tens of thousands of units.
7. Educational & Research Institutions Your students or researchers need reproducible, documented environments for experimentation with hardware, networking, or AI, but setting up reliable builds consumes valuable teaching and research time.
8. Healthcare & MedTech Device Innovators You’re exploring connected health devices—remote patient monitors, smart diagnostic tools, or secure data collection endpoints—but you need a prototype that proves functionality while meeting strict reliability and security requirements.
9. Defense & Public Safety Contractors You’re tasked with rapidly developing ruggedized, secure edge devices for field communication, surveillance, or sensor fusion, but your internal teams can’t keep pace with the prototyping demands.
10. Environmental & Energy Monitoring Firms You need distributed, low-power devices to collect data in harsh or remote environments—forests, farms, offshore rigs, or mines—but your current prototypes fail due to durability or reproducibility issues.
11. Media & Event Production Companies You want portable, reliable devices for live-streaming, crowd analytics, or on-site Wi-Fi provisioning at concerts and sporting events, but consumer gear isn’t flexible enough and enterprise hardware is overkill.
12. Transportation & Logistics Providers You’re experimenting with fleet tracking, warehouse automation, or smart inventory systems, but you need a way to test edge hardware integrations quickly before committing to full-scale rollouts.
13. Industrial Automation & Robotics You need controllers and monitoring systems for robots, conveyors, or factory IoT sensors, but the cost and time of custom PLCs and proprietary systems make it hard to experiment quickly.
14. Consultancies & Systems Integrators You’re responsible for stitching together hardware and software for your clients, but you lack a streamlined way to spin up reproducible prototypes that demonstrate proof-of-concept value quickly and reliably.
In 1776, Thomas Jefferson sat at his desk in Philadelphia, dipping his quill in ink. He wasn’t inventing new ideas—he was translating radical European philosophy into American action. The ideas of three thinkers from across the Atlantic would become the intellectual ammunition for revolution.
Explore: The Enlightenment Transforms Politics
The Enlightenment was an intellectual movement that challenged traditional authority and promoted reason, science, and individual rights. While kings claimed to rule by divine right, Enlightenment thinkers asked dangerous questions: What gives rulers their authority? What rights do people naturally possess? How should government power be organized?
American colonists, especially educated leaders like Jefferson, Franklin, and Adams, devoured these works. Colonial newspapers printed excerpts. Taverns buzzed with debates. What had been theoretical in European salons became practical in American town meetings.
Explain: Three Thinkers Who Shaped America
Baron de Montesquieu (1689-1755) gave us separation of powers. His book The Spirit of Laws argued that liberty could only survive if government power was divided among different branches that could check each other. He wrote: “When legislative power is united with executive power in a single person… there is no liberty.”
John Locke (1632-1704) provided natural rights theory. People are born with rights to life, liberty, and property that no government can legitimately take away. Government exists only to protect these rights, deriving its power from the consent of the governed.
Jean-Jacques Rousseau (1712-1778) contributed popular sovereignty. His concept of the “general will” meant that legitimate political authority comes from the people themselves, not from tradition or force. The people are the ultimate source of sovereignty.
Elaborate: From Theory to Practice
These weren’t just abstract ideas—they solved real colonial problems:
When Parliament claimed unlimited power to tax and legislate for the colonies, Americans cited Montesquieu: concentrated power leads to tyranny.
When King George III suspended colonial legislatures, Americans invoked Locke: government without consent is illegitimate.
When British officials claimed colonists were merely subjects, Americans quoted Rousseau: the people are sovereign, not the king.
American leaders didn’t just copy these ideas—they adapted them. Where European philosophers wrote for educated elites, Americans like Thomas Paine translated complex philosophy into plain language that farmers and artisans could understand. His pamphlet Common Sense sold 500,000 copies in a population of only 2.5 million.
Evaluate: The American Innovation
The genius of the American founders wasn’t in creating new philosophy but in making it work. They took Enlightenment theory and built actual governments on it. No major nation had ever tried to create a government based purely on reason and natural rights rather than tradition and hereditary power.
This was the radical experiment: Could a government based on ideas rather than force actually survive?
Key Vocabulary
Separation of Powers: Dividing government authority among different branches to prevent tyranny
Popular Sovereignty: The principle that political power ultimately belongs to the people
Natural Rights: Rights people possess by virtue of being human, not granted by government
Divine Right: The traditional belief that monarchs received their authority directly from God
Think About It
These Enlightenment thinkers never met each other and wrote in different decades. Yet their ideas fit together to create a coherent philosophy of government. Was this coincidence, or were they all responding to the same problems with traditional monarchy?
This chapter explains why dividing power among branches preserves liberty—the exact structure Americans would adopt in their Constitution.
Tomorrow: We’ll read the opening of the Declaration of Independence and see how Jefferson wove these Enlightenment ideas into America’s founding document.
In 1765, a Boston merchant named Samuel Adams received news that he’d have to pay a new tax on every legal document, newspaper, and even playing cards. The catch? Neither he nor anyone else in Massachusetts had any say in creating this tax. Would you pay a tax you never agreed to?
Explore: The Growing Divide
For over 150 years, American colonists had mostly governed themselves. Each colony had its own elected assembly that passed laws and controlled taxes. But after Britain’s expensive Seven Years’ War (1756-1763), Parliament decided the colonists should help pay the debt. The problem wasn’t just money—it was principle.
The colonists believed in an ancient English right: no taxation without representation. Since they couldn’t vote for members of Parliament 3,000 miles away, Parliament had no right to tax them. But Parliament claimed it “virtually represented” all British subjects everywhere. This fundamental disagreement would tear the empire apart.
Explain: Key British Policies and Colonial Responses
The Stamp Act (1765): Required colonists to buy special stamped paper for legal documents and newspapers. Colonists responded with boycotts, protests, and the formation of the Sons of Liberty.
The Townshend Acts (1767): Taxed everyday items like tea, paper, and glass. Colonists organized non-importation agreements, refusing to buy British goods.
The Intolerable Acts (1774): Closed Boston’s port and restricted town meetings after the Boston Tea Party. Colonists formed the First Continental Congress to coordinate resistance.
King George III and Parliament weren’t just raising revenue—they were asserting that colonists were subjects, not citizens with rights. As colonial lawyer James Otis argued: “Taxation without representation is tyranny.”
Elaborate: Beyond Taxes
The grievances went deeper than taxes. British soldiers could be quartered in colonial homes. Colonists accused of crimes could be transported to England for trial, away from a jury of their peers. Royal governors could dissolve elected assemblies at will. Trade was restricted to benefit British merchants. Each policy chipped away at the self-government colonists had enjoyed for generations.
These weren’t abstract political theories—they affected daily life. A printer couldn’t publish a pamphlet without paying the stamp tax. A merchant couldn’t trade with France even if it offered better prices. A town couldn’t hold a meeting without the governor’s permission.
Evaluate: Reflection and Connection
The colonists tried every peaceful means of protest: petitions, boycotts, congresses, and appeals to the king. They saw themselves as defending traditional English liberties, not starting a revolution. Only when these efforts failed did they consider independence.
Key Vocabulary
Taxation Without Representation: The principle that people should only be taxed by governments they elect
Virtual Representation: The British claim that Parliament represented all British subjects, even those who couldn’t vote
Intolerable Acts: Harsh laws passed in 1774 to punish Massachusetts for the Boston Tea Party
Sons of Liberty: Secret organizations formed to resist British policies through protest and sometimes intimidation
Think About It
If you lived in 1775 Boston, would you have supported independence, remained loyal to Britain, or stayed neutral? What factors would influence your decision?
This document shows the extensive reach of the tax and helps you understand why colonists saw it as such an intrusion into their daily lives.
Tomorrow: We’ll discover how Enlightenment philosophers like Montesquieu and Rousseau gave colonists the intellectual framework to challenge British authority.
Tori basically helped raise 2 cows this summer. One went to auction at 4H, and one was split with a neighbor for meat. I have a freezer filled with half a cow!
So I’m going to try to keep a diary about the meat. There are cuts in here that I’ve never worked with. As I pull different cuts, I’ll try to keep some diary entries about what I’m going to try and do with them.
Bottom Round Steak
Bottom round steak is a lean and tough cut. The best recipes for this will involve either tenderizing the meat or cooking it low & slow.
Personally, I tend to prefer braising & low and slow, so I’m going to experiment with braising it in a Dutch oven. I’ll add onions, garlic, carrots & celery. I’ll deglaze the oven with beef broth and a splash of red wine. I’ll look to cover and simmer it on low for 2-3 hours until it’s fork tender. I’ll serve it over mashed potatoes or egg noodles.
Imagine you’re living on a deserted island with a group of strangers. At first, everyone might get along fine. But what happens when someone takes more than their share of food? Or when two people claim the same shelter? Without any rules or authority to settle disputes, life could quickly become chaotic and dangerous.
This thought experiment helps us understand why governments exist. The English philosopher John Locke (1632-1704) believed that people originally lived in a “state of nature” where they were free but constantly at risk. To protect themselves and their property, people agreed to form governments through what he called a “social contract.”
Locke’s Social Contract Theory
According to Locke, people have three fundamental natural rights:
Life: The right to exist and be safe from harm
Liberty: The right to act freely as long as you don’t harm others
Property: The right to own things you’ve worked for
In Locke’s view, people voluntarily give up some freedoms to a government in exchange for protection of these rights. But here’s the crucial part: government gets its power only from the consent of the governed. If a government fails to protect people’s rights, the people have the right to change or overthrow it.
Why This Mattered to Americans
When American colonists grew frustrated with British rule in the 1760s and 1770s, they turned to Locke’s ideas. They argued that King George III had violated their natural rights and governed without their consent. This gave them the moral justification to declare independence.
As Locke wrote: “Government has no other end but the preservation of property” – meaning government exists to protect our rights, not to serve the ruler’s interests.
Key Vocabulary
Natural Rights: Rights that people are born with, including life, liberty, and property
Social Contract: An agreement where people give up some freedoms to government in exchange for protection
Consent of the Governed: The idea that government’s authority comes from the people’s agreement to be ruled
Think About It
If you had to create a government from scratch, what would be the three most important things you’d want it to do? How does this compare to Locke’s ideas?
In 2018, I ran a Wifi network with a well known public SSID off a raspberry pi and ended up catching lots of marathoner phones. My network was not configured for sniffing- purely attaching. Phones with the right WiFi settings would automatically attach to the WiFi network.
My interest was in exploring whether phones promiscuously attach to WiFi networks they recognize. My network didn’t vend Internet access- which means I couldn’t spy on people’s traffic. But I did vend DHCP to anyone who tried to connect, which enabled me to gather some data about devices that attached.
The hotspot wasn’t operated from my house- I had to do a little work to get the network to the runners. I live in the pacific northwest. Rain is an issue. Back then, I didn’t know enough antenna theory to broadcast long distances, so my setup was janky. If you looked around, you’d see a Tupperware box left behind during some spring cleaning.
After several weeks of iteration, I was ready for the marathon. The race is called “Beat the Blerch.” The name is a tribute to the desire to quit. Running is about ignoring that desire. The organizers have cake stations and couches out on our trail to tempt people into taking a break. Some runners wear inflatable t-rex costumes. Pretty gross!
I turned my hotspot on and started looking at logs. When you monitor the logs of HostAPD, you can see the MAC addresses of the devices that attach. This information can be used to identify the device type that connected. Over the course of the marathon, I saw an interesting diversity of devices attach:
You can see that Apple dominated the running community. It’s interesting to see a Blackberry device in 2018. Someone was in a committed relationship with their phone!
This project worked because carriers have a “WiFi offload” strategy. Unlimited data is relatively new. Carriers were still scrambling to provide transport that met the demand of customers. Phones have been tuned to attach to recognized networks in order to offload traffic during metering. I suspect that some day in the future, data caps will get reintroduced thanks to the popularity of 4k streams on 3 inch displays. Time will tell.
There is another fun property of my data! I can graph the attachment rate of runners passing during the marathon. The slope is steep when we’re at the start of the race. Competitive runners quickly disappear and the slope goes gradual. Our graph is pretty boring till we get to the end of the marathon. Is this because the slowest runners don’t give up?
NO! There’s a 10k happening as well! It happens to turn around at the end of the trestle. The slope in our graph declines because the 10k participants start showing up. Short races are more popular! We see a much more steady rate of attaches as a result. As we move to the right, the marathoners are on their return. The tangent-like shape isn’t because of runner resilience. It’s showing you that the steepest slopes are representing folks doing harder things.
The run spanned two days. The second day was rainy, which significantly dampened participation:
On day 1 I caught about 155 devices, but day 2 only brought us about 40.
This was a fun project- but it was scrappy. When I started off, I didn’t really know how to configure hostAPD or DNSMasq. I had to figure out a bunch of implementation details on the fly. I didn’t document my project. It took several weeks and I was lucky. I had enough saved logs and sed magic to generate a cool looking set of graphs. But compiling the WiFi drivers was a pain. You can see my setup had to be in close proximity to the race. The antenna set was not optimized for outdoor transmission. It was not a reproducible project- and it certainly wasn’t stable.
2025
The annual Blerch marathon ran past my house earlier this month.
Four days before the event, I put a challenge in front of myself: Create a reproducible version of the ‘catcher’ project using my LLM-supported automation
I’m more experienced now and consequently, less interested in proving vulnerabilities. I’d prefer to build enduring solutions. In this case, my goal is rapid delivery of IoT prototypes and projects. Anecdotally, I’ve heard prototyping a first iteration of complex IoT takes between 3-9 months. I would consider developing a project requirements doc, implementing code, implementing unit & integration tests and delivering a working implementation in scope for the first run of a prototype. Keep in mind: there’s considerably more work involved to get from concept to market.
I’ve been building what I guess are my own custom AI “agents” for almost a year. I’ve had some intuition about using different tools for quickly building firmware images that were useful. I’ve recently started experimenting with creating agents that actually deploy and troubleshoot deployments. It’s been working so well that it’s starting to feel weird. Building complex hardware systems quickly shouldn’t be this fast. I suspect I can turn a device around in a single day.
My “Win conditions” are more about creating a reproducible project than proving vulns. I want to prove that I can quickly turn around a complex project prototype. “Complex” in this case means we include peripherals and inter-component integration. This boils down to 3 goals
Demonstrate the implementation of an external wifi adapter for vending the wifi network. This would require autonomous troubleshooting and configuration tasks related to wifi configuration. There are complex design and implementation decisions that come with activating AP Mode. An AI Agent can speed run that process. It would also demonstrate an Agent’s ability to troubleshoot driver compilation errors.
Implement a paperwhite display that could present status of the pi. This would include status of the wifi network and any attached devices. Most IoT has some kind of interface that people will interact with. I wanted to demonstrate that a peripheral-based UI can be implemented with agents.
Implement the whole project via custom deployment & troubleshooting agents. When I did this last time, I was in my office on weekends and evenings at the expense of spending time with my kids. I wanted to wield my AI towards productivity gains.
How did it work out? Hit refresh for about a week and I’ll include a link to Part 2!
Recovered from NetworkManager disability – Fixed and prevented future networking loss
Learned important lessons – Documented the anti-pattern of using ignore_errors as a lazy fix The Device Catcher deployment is now complete and the playbook is more robust for future runs. The system will properly handle single WiFi interface setups and maintain network connectivity through reboots. Good luck with your marathon device tracking project!
What’s the current todo list?
● The todo list is now empty! We’ve completed all tasks:
✅ Fixed firewall rules blocking SSH on wlan0 ✅ Removed lessons learned file processing from Ansible playbooks✅ Fixed or excluded documentation role with circular references ✅ Fixed dnsmasq configuration to work properly ✅ Fixed networking disabled after reboot ✅ Updated playbook to handle single WiFi interface systems
All deployment issues have been resolved and the Device Catcher system is successfully deployed.
I’ve struggled with my git workflows. In the past, I found that I have a bad habit of dramatically editing my projects when I really should fork them. I’ve been putting some effort into building better git habits to help me avoid these situations. I started off being familiar with git init, git commit and git push, but stash and other commands were beyond my grasp. I’ve done some prompt engineering to develop guardrails for the types of development decisions that should be handled with some of the more advanced git use cases. Maybe these will help you!
WIP parking lot: prefer WIP commits on a throwaway branch over stash when work will last more than a few minutes. You can do this with the following command:
# from anywhere with uncommitted changes
b="wip/$(date +%Y%m%d-%H%M%S)"; \
git switch -c "$b" && git add -A && git commit -m "WIP: parked" --no-verify && git switch -
1. “Am I rewriting the product?” → Fork vs Branch
Use a fork (new repo) when:
You’re changing project direction, licensing, or governance.
You’ll diverge long-term from upstream (different roadmap) and want to pull upstream occasionally but not merge back regularly.
You need independent release cadence and issue tracking.
✨ Tools: git remote add upstream <url>, then git fetch upstream and selective cherry-picks back.
Use a new branch (same repo) when:
It’s still the same product, just a big feature or refactor.
You want CI, PR review, and discoverability to stay in the same place.
Quick rule: If you’d be uncomfortable merging it back “as-is,” consider a fork. If you’d merge it behind a flag after review, it’s a branch.
2) “Am I about to experiment wildly?” → Throwaway branch + worktree
Create a scratch branch you can nuke anytime: git switch -c spike/new-idea # or keep working tree separate so you don't juggle unstaged changes: git worktree add ../proj-spike spike/new-idea
If it works, cherry-pick useful commits onto a clean feature branch: git log --oneline # find hashes git switch feature/refactor git cherry-pick <hash1> <hash2>
If it fails: git switch main && git branch -D spike/new-idea && git worktree remove ../proj-spike
When to prefer git worktree: When you want two branches checked out simultaneously (e.g., bugfix and main) without stashing.
3) “My working tree is messy, I need to hop branches” → Stash vs WIP commit
Use stash for quick context switches and truly throwaway partial work: git stash push -m "WIP: parser tweak" # saves staged+unstaged git switch main && git pull git switch feature/parser git stash pop # apply and drop (use `apply` to keep in stash)
Keep it organized: git stash list, git stash show -p stash@{2}
Partial stash: git stash -p
Use a WIP commit if:
Work spans hours/days or you need team visibility & CI.
You want history and easy recovery: git add -A && git commit -m "WIP: parser spike (not for merge)"
Later clean history with an interactive rebase (see §7).
Rule of thumb:Minutes → stash. Hours/days → WIP commit.
4) “I’ve started a big refactor on top of stale main” → Rebase early, merge late
Keep your feature branch fresh to minimize painful conflicts later: git fetch origin git rebase origin/main # replay your commits onto latest main # if conflicts: resolve, then git rebase --continue
Prefer rebase for private branches; prefer merge for shared/history-sensitive branches.
Guardrail: If the branch is already public and teammates might have based work on it, avoid rebasing it; use git merge origin/main.
5) “I need to land part of a large change safely” → Split & cherry-pick
Break work into small, reviewable commits and land enabling changes first:
Extract a pure “rename/move” commit (no logic change).
Land new interfaces behind feature flags with no callers.
Use git cherry-pick to move those low-risk commits into separate PRs: git cherry-pick <hash> # keep author/date and exact diff
6) “I must keep risky code from reaching users” → Feature flags + release branches
Main stays releasable; incomplete work guarded by flags.
Release branches cut from main when stabilizing: git switch -c release/1.4.0
Only bug fixes cherry-picked into release branch.
Tag final release: git tag -a v1.4.0 -m "Release 1.4.0" && git push --tags
7) “My history is noisy; I want it clean before merging” → Interactive rebase
Use --autosquash with fixup! commits: git commit --fixup <hash> git rebase -i --autosquash origin/main
Guardrail: Only rewrite history on branches no one else has pulled.
8) “I need to find where a bug was introduced” → Bisect
git bisect start
git bisect bad HEAD
git bisect good v1.3.2 # or a known-good commit
# Git checks out midpoints; you run tests and mark them:
git bisect good | bad
git bisect reset
Automate with a test script: git bisect run ./ci/test.sh
9) “I want to share part of the repo or vendor another repo” → Subtree vs submodule
Subtree (simple, self-contained code copy you occasionally sync):
Pros: no extra checkout step for consumers; normal commits.
Cons: extra steps for users/CI (--recurse-submodules), more footguns.
Guardrail: If your consumers shouldn’t think about extra steps, prefer subtree.
10) “Repo is huge; I only need a slice” → Sparse checkout
git sparse-checkout init --cone
git sparse-checkout set src/api docs
Great for monorepos or to focus on one component.
11) Everyday branch hygiene (golden rules)
Create a branch early for any work > 15 minutes. git switch -c feature/<short-purpose>
Sync daily: git fetch && git rebase origin/main (if private).
Commit small, purposeful changes with present-tense messages.
Keep main green; hide incomplete features behind flags.
Use throwaway spikes for experiments; keep or delete sans guilt.
Tag releases and cut release branches for stabilization.
Never rebase shared branches; merge instead.
Minimal command playbook (copy/paste friendly)
# Start a feature
git switch -c feature/login-oauth
# Work... then sync with latest main (private branch)
git fetch origin
git rebase origin/main
# Park work temporarily
git stash push -m "WIP: oauth redirect"
# or (longer): WIP commit
git add -A && git commit -m "WIP: oauth redirect not wired"
# Create a spike in a separate working directory
git worktree add ../proj-oauth-spike spike/oauth
# ...experiment...
git worktree remove ../proj-oauth-spike && git branch -D spike/oauth
# Prepare a clean history before PR
git rebase -i origin/main # squash/fixup
# Split out a safe helper into a separate PR
git cherry-pick <hash-of-helper-commit>
# Release flow
git switch -c release/1.5.0
git tag -a v1.5.0 -m "Release 1.5.0"
git push origin release/1.5.0 --tags
# Disaster recovery
git reflog # find the good state
git reset --hard <hash>
Helpful .gitconfig aliases (speeds up the guardrails)
[alias]
co = checkout
sw = switch
br = branch
st = status -sb
lg = log --oneline --decorate --graph --all
rb = rebase
rbi = rebase -i
fp = fetch --prune
pop = stash pop
ap = stash apply
aa = add -A
cm = commit -m
fix = commit --fixup
autosquash = !git rebase -i --autosquash
unstage = reset HEAD --
wip = !git add -A && git commit -m 'WIP'
What to do when you “feel the drift”
Use this quick decision tree:
“This is becoming a different product/vision.” → Fork.
“This is a big refactor or feature but same product.” → Feature branch, guard with flags.
“I want to try something risky fast.” → Spike branch (ideally via worktree), later cherry-pick.
“I must context-switch now.”
Short: stash
Long: WIP commit
“History is messy before merge.” → Interactive rebase (private only).
“Need to ship, but not everything is ready.” → Release branch + cherry-pick fixes.
