No rain from May to September, the same water for every bed… And three very different stories underground.
Our HydraScout dashboard for the hügelkultur bed on 9 October. Left: soil moisture and temperature at 20, 40, 60 and 100 cm. Right: how full each layer’s usable water reserve was over the past week, from wilting point (PMP) to field capacity (CC): nearly empty near the surface, partly full at 40 cm, brim-full at 60 cm and 1 m.
Back in April, Mud Valley Foundation and Quinta Vale da Lama installed three soil moisture probes in the farm’s market garden, as part of the EU-funded MORFeuS program. Each probe reads soil moisture and temperature at four depths (20 cm, 40 cm, 60 cm and 1 m) around the clock.
From May to September it didn’t rain at all. Every drop those beds received came from our irrigation system, and each bed got the same amount. That makes this first summer a rather good natural experiment: same water, same sun, three different soils. Here’s what happened to the water.
Three beds, three stories
The hügelkultur bed (West Garden, perennials). Here the water went down, and stayed down. After each watering, the sensors at 40 cm and 60 cm responded within a day or so, and over the summer the 60 cm layer actually got wetter, rising by about a third, in a season with no rain. The buried wood at the heart of the mound seems to be doing what we hoped: soaking up water and holding it where roots can reach it. The surface, meanwhile, was the driest of the three beds, as water drained quickly into the mound below.
The alley-cropped annual bed (West Garden). This bed told a story of calm. From 40 cm down, moisture barely moved all summer: the readings at 40 cm and 60 cm were almost flat lines from May to September, and the 1 m sensor ended the season where it began. All the action was in the top 20 cm, where the annual crops were drinking, and which lost about a third of its moisture. Underneath, a steady reserve sat largely untouched.
The East Garden (our control, with few soil interventions and no trees). This bed had a hard start. It flooded badly earlier in the year, with standing water for weeks. Through the summer its middle layers, 40 cm and 60 cm, lost around half their moisture, partly drying out after the flood and partly because irrigation barely reached them: the water stayed near the surface. Only the deepest sensor, at 1 m, held steady.
What we can (and can’t) say yet
This is one season, with one probe per bed, and the flood muddies the comparison with our control. So these are patterns, not proof. But they’re striking ones. The beds where we’ve worked the soil, building in organic matter and carbon, are keeping water in the root zone through a Portuguese summer without rain. The control bed is not.
From the calendar to the ground
Right now, like most farms, we water on a schedule: so many minutes, so many days a week, whatever the soil is actually doing. This summer’s data shows what that costs. In one bed the subsoil stayed comfortably moist all season, while in another, water never got past the surface.
Our aim for the coming seasons is to turn that around: to evolve our irrigation from being schedule-driven to being driven by conditions on the ground. That means watering a bed when its root zone tells us it needs it, at the depth where the plants are drinking, and not before. In a semi-arid region where every litre counts, letting the soil set the schedule may be the most water-wise thing we can do.
Why does a farmer spend his evenings on Github? Because Good Governance needs plumbing -and this is the best we have got
As “ReFarmer Walt,” I feel myself prompted to respond to the question: Why are you spending so much time geeking about Github these days? To which question, i have tended to mumble something about replacing legacy softwares, building more resilient & robust infrastructures for our enterprise, etc. Yet in truth, some of this is tooling that we are not using in production, that is not mine to maintain, so… What is all this about, and why does it matter?
Essentially: it is about Good Governance -a concept that is seriously lacking in practical application on all fronts, it seems these days- which now more than ever requires something that used to be called “Groupware,” a term that fell out of favor many moons ago, but it was a hot topic around the turn of the millenium. In the middle of all that hoo-ha around big vendor “solutions”, there was a book by Jon Udell called Practical Internet Groupware that set forth an alternative approach, based on leveraging the power of a few open standards (IMAP, NNTP -stuff that predates the WWW, even) to solve the simple problem of coordinating work within and between teams that can’t always meet. That was the case in my enterprise, of some hundreds dispersed across multiple time zones, which became a project i led to an unsatisfactory (for me, anyway) compromise, involving commercial software that was too stiff, expensive, and unresponsive to our evolving needs. So for me: this went down in the books as: lost the battle, but came out of it a wiser man determined to fight another day (like Gen. MacArthur: “I shall return” :-) )
Fast forward a quarter century to now, when the challenges are much more complex (more about those below), i am now a Senior Citizen (if 65 qualifies me -i don’t know, they keep moving the goalpost!), and the tools are changing so fast from one day to the next, it is impossible to keep up. NOW onto this stage, who should walk but the very guy who so informed & inspired me all those years ago, with- once again! -a refreshingly simple solution that leverages the power of a rock-solid internet infrastructure (i.e. Github) –this time in the form of a FOSS product that brings AI into the loop in such a way that humans can retain as much control as they deem appropriate, thereby ushering-in the era of “Vibe coding as a team sport.”
Now as to the WHY: 3 reasons
My enterprise requires it
Generally speaking, farming is a complex biz -mine as much as any, despite its modest size. We need software that can be customised to meet ALL the diverse needs in all the different domains, from Agronomy to Zoology and everything in between, including Finance, Marketing, Policy -all that stuff we ReFarmers wish desperately to delegate (but not dump, mind you!)
This business of Responsible Delegation is big with me these days -both because of advancing age, and my inclination (what i try to keep in check, being well aware, but still:) to “move fast, break things” and leave a mess for our more detail-oriented people to pick up after. Succession is my Job#1 these days: not a matter of grooming a special some-one to fill my shoes, but rather one of yielding authority to a system of autonomous, self-organizing roles and structured processes. This results in a rich tapestry of roles and relationships of substantive exchange in a state of constant flux; maintaining a current map of this enterprise ecosystem is possible, only by means of a bespoke software wherein everyone maintains their own part of the puzzle. HOW we do this will be the topic for another post, but as to the WHY: it is the way mother nature organizes ecosystems, which has emerged as the way that works for us on this polycultural farm -naturally enough ;-)
My community needs it
The context in which my farm is embedded faces some environmental challenges- most significantly the trend of encroaching desertification -that has served to galvanise a diverse group of players to action. Gathering farmers, fishermen and foresters together with policy makers and administrators from all levels of government: how can we really hear each other, respecting the unique perspective that each is able to provide, empowering each to do his/her part, however large or small, without stepping on each other?
Consider the case of the Linux kernel -maybe you’ve heard of it? ;-) The lion’s share of online servers depends on it, as does the majority of mobile phones (100% of all Androids). It is maintained by some thousands of active contributors -many paid by companies in direct competition with each other (Intel and AMD, Google and Meta) who have every commercial reason not to trust one another. Coordinating development of that single artefact continuously over thirty-five years -mostly without ever meeting- is possible not because they’re unusually virtuous, but because the tooling makes every proposal public, every decision attributable, and every rejection reviewable. So what is that tooling? In a word, the answer is: GIT (that, and a process of Governance oriented to the common good). [1]
Personally, i am in awe of that project -and moreover jealous that they can all agree to adopt the same powerful tooling. It helps that they are by definition coders… But things have changed since the early days of Linux, both in terms of User Interface and user capabilities, such that it is possible for anyone to see what the coders are up to, submit issues to them, track the progress, and participate in decisions about where development is going. For this reason, i have stood up a Github repository for collaborative development of our community’s not-yet-published/ soon-to-be-celebrated website. Watch this space for more news on that front!
The world is breaking for want of it
… and that “it” is, in a word, Accountability. Easy as it is these days to state one’s position and broadcast it to the world, as the results of such position-taking emerge in the fullness of time, the process of recalling those positions and holding their authors to account can be difficult if not impossible -even in a court of law. Consider the case of Zuck v Sarah Wynn-Williams, the case of Sam v. Elon … The list is endless -all fights about what was actually said and agreed, and when, where the record is contested, private, or destroyed. That is precisely what an issue thread with diffs and timestamps provides: Institutional Accountability (IA: a necessary concomitant, in the age of AI?). And hey: if it can work for a licensing dispute, one can dream about harder cases (like world leaders who wage war without proven justification, maybe?) ;-)
Speaking of dreams, i must confess that if there is one dream i hold most dear: it is that my kids & their progeny will one day live in a world where Might != Right. Why this is so strong in me, i am not sure; i was never bullied (excepting that once in middle school, but then… Long story short: i put an end to it quickly enough), yet: I witnessed episodes of bullying, where i should have and maybe could have helped, and didn’t. Maybe you too can relate. Anyway: it just makes me sick.
SO: Since those Groupware fandangos of ~y2k, having lived and learned-from my share of battles ever since, i feel like the time for pussyfooting around is past. The time is now, we have the know-how and the resources, so… As the Big Chief once said: “I have returned.”
“I have returned.” Leyte, 20 October 1944. Photo: Gaetano Faillace, U.S. Army Signal Corps.
[1] NB: the tooling doesn’t produce Good Governance, it produces an unfalsifiable record. Bad decisions get recorded just as faithfully. What it removes is the ability to be vague later. Most governance failures are failures of vagueness, not of intent.
Taking my cue from Andrew Shell (of rssCloud Server fame, about which you will be hearing more soon ;-), i have added a little feature to the footer of this site, which expresses my appreciation to Dave Winer, Andrew and the wonderful RSS community, which makes syndication of all sites great and small Really Simple!
I just learned that it’s possible to join this WordPress blog to the Fediverse, by simply activating the ActivityPub plugin that is already installed… So let’s see if this works!
Technical or not, human or AI – could Bram be the missing link?
Bram at work on my own repo: the agent’s terminal on the left, the artifact it’s building on the right. Screenshot by the author.
In “What Is the Terminal?” Jon Udell frames the problem that his new product Bram aims to mitigate -and does surprisingly well, considering how new it is. The terminal has become far more approachable and powerful in this age of AI agents for everyone; you can now ask, in plain language, for the software you want, and watch an agent go build it. And yet, for exactly that reason, comprehensibility of all that it is doing has become more of an issue than ever, for users of every stripe, however technical they may or may not be.
The easy reading of Jon’s title is that Bram makes the terminal optional for people who fear it: “The terminal is a foreign and hostile environment. Now it’s optional,” he writes, and that much is true. But the sharper point is the one that lands for experts too. In the age of AI agents the terminal has become a firehose: agent messages, your messages, tool calls, file reads, diffs and command output… All streaming past faster than anyone can absorb. Nobody- not the rawest beginner, nor the most seasoned engineer -takes in all of it in real time. That loss of comprehensibility is now a well-worn complaint in developer circles, and it’s the problem Bram is really built against.
So this isn’t “the terminal for dummies.” Jon is explicit that the payoff reaches the pros: “if you are a terminal jockey,” he writes, “you may enjoy the more legible display of agent messages, your messages, pasted screenshots, diffs, tool calls and results.” That’s the tell. Bram isn’t hiding the work and dumbing it down for the beginner; it’s making the same work legible- for the newcomer who never wants to see a shell, and just as much for the veteran who lives in one and still can’t take in the torrent an AI agent throws off.
And legibility here is a set of concrete mechanisms, not a mood. Instead of one linear stream rushing past, Bram decomposes the work into surfaces you can actually inspect: a worklist of discrete tasks, a transcript of the exchange, readable diffs, an issues panel and a commits panel; those are the tabs running down the screenshot above. And between the agent proposing a change and that change touching your files, it interposes explicit gates: you approve what gets applied, then separately approve what gets committed. That is where comprehension is recovered- not by slowing the agent down, but by turning the firehose into discrete things a human can see, review and sign off on, one at a time. It is exactly what a developer needs in order to stay responsible for code they did not personally type.
Here’s why that matters to me beyond the code. The teams I care about are hybrid in two directions at once. They mix technical and non-technical people: a farmer, an editor, a designer, a programmer. And, increasingly, they mix humans and AI agents working the same tasks. For twenty years, GitHub gave software teams a shared substrate for exactly this kind of collaboration: issues to name the work, commits to record it, review to bless it. What it never did was welcome the people who would never open a terminal, or the agents now working alongside them.
That’s the missing link I think Bram might be. Not “GitHub for programmers,” but GitHub for today’s hybrid teams: the same legible, reviewable, version-controlled way of working, extended to everyone at the table, human and machine, coder and not. The agent proposes; a person understands enough to approve; the record is public and portable.
And notice the shape of this very post. I’m not replying to Jon inside some platform’s walled garden. He wrote on his blog; I’m answering on mine; a pingback will quietly connect the two, and RSS will carry both to whoever’s subscribed. Read in, written out, via the same interface, the way Dave Winer has always said the social web should work. It’s the same instinct as Bram: keep the substrate open, keep the work legible, and let people- and their agents -meet on ground nobody owns. This ground is sacred; let us work to protect it.
Still more white than pink, in fact, but becoming more pink by the day (something to do with their diet, i gather), the wife & i have been seeing these birds in the early hours of each day, heading out on our morning walk… Then gone, an hour later on our return home, to who-knows where, though i suspect the Ria de Alvor estuary. They don’t “Murmurate” like the starlings, as i know from the one time i caught them departing, but stream off like a flock of arrows, heading East into the sun, now well over the horizon. Can’t count on their always coming back, as this pond is bound to dry up before we get much deeper into summer… So these mornings that we are graced with their visit are a blessing: a gift of our beloved landscape.
A murmuration -that vast, shape-shifting flock of starlings wheeling over a winter field at dusk- has no lead bird, no server, no committee. Each starling simply reads its nearest neighbors and adjusts. Out of that purely local, permissionless reading comes coordination of breathtaking complexity, with no one in charge.
That is the protocol I want for organizations, regardless of size, budget and technological capacity.
The aim is small and stubborn. Let an organization publish the handful of things that actually define it- who it is, where located, what it offers and needs, who it’s tied to- once, at a URL it controls, in a shape any other entity (human or machine) can read. Publish it the way you’d publish a blog post: out in the open, owned by you, syndicated by anyone, captured by no one. Not a platform everyone has to log into, but a way for organizations to read each other directly, so that the coherence is emergent rather than administered.
The good news is that none of this needs inventing. The parts already exist, and have for twenty years. I’m not building a new platform; I’m assembling standing ones:
The stable profile is a plain JSON file at the organization’s own URL, typed with schema.org so a machine knows what it’s looking at.
The live layer is RSS: a new land offer, a want fulfilled, a seasonal event, flowing out the same feed nearly every CMS already emits.
The part that makes the live side honest is RSS Cloud, which turns the feed from polling into push, so a 72-hour offer propagates in seconds instead of waiting on somebody’s timer.
My own daily reading already runs on this stack, with Dave Winer’s FeedLand at the head of it. I’m building on the standard because the standard is the thing that has outlasted everything stacked on top of it. This is what Really Simple buys you: nothing to depend on but the web itself.
A word on the name, since it invites the question. There is a project called Murmurations : a small, volunteer-run index for exactly this kind of profile, and a good one. I use it. But I want to be precise about its role, because the whole sovereignty of the thing turns on it: Murmurations is an optional discovery layer: a place your profile can be found, not a place it has to live. The canonical copy stays at your URL. Register with that index, with three indexes, or with none and just hand out the link; the data and the feed don’t care. If every index went quiet tomorrow, every profile would still resolve and every feed would still flow. I’m leaning on the metaphor more than the product. The flock is the point; an index is just one pair of binoculars.
There’s a posture underneath all this worth naming, because it’s why I’d rather build on bare standards than on anyone’s platform. The organizations are the Masters here; the software, including the AI agents I work with, are the Emissaries (hat-tip to Iain McGilchrist here). The agent drafts, fetches, refactors, tirelessly doing the analytical labor; the human sets the intent and keeps the meaning. Sovereignty isn’t a feature you bolt on at the end. It’s the consequence of keeping the data and the tooling under your own hand from the first line. A standard you can read in an afternoon is a standard you can stay master of. A platform is not.
I owe a second debt here, to Jon Udell, who has spent decades arguing for structured, syndicatable data that doesn’t rot inside a silo. This post, and the code behind it, were built the way he describes in Vibe Coding as a Team Sport: a human and a coding agent working through a shared, checkable record rather than a pile of hidden chat logs. His tool Bram is the harness: just enough ceremony to keep the agent honest. I mention it because the how is part of the claim: if the history of building the tool is as open as the tool itself, the whole thing stays inspectable, forkable, and yours. Gardens, not platforms, all the way down.
So here’s where it stands. It’s early: there’s nobody in this flock yet but me and Claude (my trusty emissary :-), and it’s my entry into a hackathon running through July. But it’s up, it’s in the open, and it speaks RSS in and out. This post answers a standing invitation from Dave Winer, who’s been rebuilding interop for the social web on exactly these foundations and asked anyone working in the same direction to put up an app and see who works with it. So that’s the test I’m after: if this can interop cleanly with rss.chat, it can interop with the rest, because that is what building to the standard means.
If you’re reading this and you build, fix, or fly with any of it, come find me. It’s all in the open so it’s useful to whoever lands here next and wants to join the flock.