Want to join in? Respond to our weekly writing prompts, open to everyone.
Want to join in? Respond to our weekly writing prompts, open to everyone.
from
Larry's 100
Red Sonja: Consumed by Gail Simone (2024)
Helming Robert E. Howard's Red Sonja, author Gail Simone demonstrates a bard's touch for the Sword & Sorcery genre.
Simone celebrates the character's excesses and writes her lively action sequences, on the battlefield and in the bedroom. At times, overburdened by side quests, but the epic boss battles thrill with clear emotional stakes.
Chapters opening with historical documents, folklore, and societal analysis ground the narrative in a larger world but in inventive ways.
The Falcon's “Blood Man” is a devastating character study of violent male fragility. His POV chapters are like reading the manifesto of a real-world incel terrorist.
Read it.
#BookReview #SwordAndSorcery #RedSonja #GailSimone #Drabble #100WordReview #Bookstodon
from Tony's stash of textual information
The wrong kind of solitude is vinegar The right kind of solitude is oil
- Jane Hirshfield
Who first introduced me to alcohol? There is a man, there is always a man. Or boy.
I was twenty years old, I was a soldier in the army of [redacted] country. My fellow twenty-year-old soldiers – mischievous young boys that we were, itching for danger and some female attention – suggested we go to a certain place to buy some drinks.
There were no girls that night. Or, if there were, they were talking with other men in the venue, not with this gaggle of young boys that clearly were trying too hard to look cool.
From these boys – who have been trained to load a rifle, and to fire at a target with a certain degree of accuracy and consistency – I encountered the unsophisticated drink known as Martell cognac, mixed-with-Pokka-green-tea.
I was twenty-three years old, I was alone in a Northern country, far from my Southern bubble of comfort and familiarity.
I was assigned a room with a grinning, well-dressed Japanese young man... or boy.
On the first night I met him, he said, “I'm one of the few Japanese people who can speak English well.” In hindsight, that may or may not have been a factually accurate statement, but it worked; I was charmed.
Cordialities over, he asked the important question:
“do you like drinking? My friends and I, we like to go to Bobs.”
“Bobs?”
“Yes, it's short for Bobwundae.” [editor's note: Bobwundaye is a phrase in dialect; it means “no problem.”]
I was a little scared to appear not-cool in front of this new male figure, and I wanted to fit in with my new room-mate, so I said, “yes, I drink sometimes.”
Some weeks later, we went to a nearby bar. Actually, it was quite gringy. It wasn't a bar, it was a watering hole. Or a “dive bar”.
My then-roommate ordered a drink that came in fancy glassware – coupe glass or martini glass, I cannot remember.
I tried so hard to find a topic that would be “cool enough”. Mid-way through this chat – that had me nervous all the time – he stood up and lost his balance; his feet seemed not to obey him. He staggered and struggled to walk in a straight line.
“Are you okay?”
“Uh... the drink is a bit strong,” he managed to verbalise.
I was twenty-seven years old, I looked up Alcoholics Anonymous (AA) on the Internet, to find a gathering near me.
The group numbered about twelve in size, mostly men, with a few women. I shall not reveal their age nor ethnicity nor profession.
I learnt about a Twelve-step Programme, and I received a book. The book.
It was The Book, but it was certainly not the Holy Bible.
The Book had the words, “there is electricity in the air, when people like us gather together.”
But at the AA gathering I attended, there was no electricity, only a sense of quiet desperation.
To end the gathering, we stood in a circle and held hands. [redacted]'s palm, which I was holding, was sweaty.
“If you do the work, the change will work,” we chanted. Or something like that, I cannot remember.
I was twenty-eight years old. I stumbled upon a fancy-looking room in a Centre For Performing Arts.
With no small trepidation I stepped in.
A middle-aged man, well-dressed in vest, button-down shirt, and trimmed moustache, looked over his spectacles, and said, “Hi.”
I would visit him – and his wife – regularly, over the next seven years. (It was a husband-and-wife shop).
But circumstances conspired in such a way that he decided to close down his shop permanently. On the final few days of his shop's operations – I was thirty-four years old by then – he said:
“I'm surrounded by these bottles. But I don't need them. I'm not dependent on them, for my happiness.”
#talmid #CraftingStories
from
Jall Barret

Image by Gianni Crestani from Pixabay
It's interesting watching a technology that felt new to me (even though it was quite old at the time I was using it) suddenly get renewed attention.
I still remember the first cassette album I owned. I'm sure it wasn't literally the first cassette tape I owned and I'm not sure whether I bought it with my allowance or if it was a present. I would name drop it but it turns out not all the artists from my youth listening to CCM became queer affirming. Some of them became pretty rancid!
The album meant a lot to me at the time. It's hard to think of that album without hearing the slightly imperfect warble of the tape speeding up and down just slightly as it played in my headphones.

Image by WikimediaImages from Pixabay
Eventually, we got CDs. I only had two to start with. One was Moonlight Sonata. Legend has it that the 74 minute runtime of the redbook CD was chosen to allow Moonlight Sonata to fit on a single disc. As far as I know, this isn't true but it's a great story. The other was Rich Mullins's A Liturgy, A Legacy, & A Ragamuffin Band. I still have that CD although I backed it up to FLAC when I backed up all my CDs over again.
Cassettes remained a part of my life for a little while. I used them to record songs of the radio. Particularly songs that would have been difficult for me to get albums of. Eventually, writable CDs became affordable enough to make my own mix CDs instead of mix tapes. Around that same time, I was getting into MP3 pretty heavily. The very first MP3 I ever heard was one I encoded myself. It took hours to encode that one song to 128Kbps and, when I played it on a 120Mhz Pentium Acer, I couldn't run any other software at the same time. It was so small, I carried that song on a 1.44MB floppy disk. Today, some pedant would tell me it was a 1.44MiB disk. I'd go pull one of my floppies from the protective case I store them in and offer them the use of my loupe to read the size on the label.
The last gasp of cassette tapes in my life was my four track recorder. Which only recorded two tracks at a time and required a special type of tape to really do its business.

Image by Gianni Crestani from Pixabay
A lot of ink has been spilled on why it is that people go for, say, vinyl long after it has passed its expiration date. The original releases of old music had better dynamic range (i.e. they haven't been compressed to hell and back) but tended not to have as much going on in the lower end. There may be something to that audiophile convention about analogue sound. Most professionally produced sound from the 80s onward was produced digitally at some point in the chain before it reached the listener.
To the extent that they may have a point, you'd have to listen to some really old recordings on some pretty old gear to know it for sure.
Why are folks reaching for the old stuff? I've heard it's because this stuff was the province of older siblings and cousins. Maybe there's some truth to that.
But maybe it's because there's 900 channels and nothing good on. I don't mean that literally in either direction. There are a lot more than 900 “channels” so to speak and plenty of the new stuff is really good. Maybe we have too many choices and too many distractions.

Image by blitzmaerker from Pixabay
I remember just listening to an album. I've always been me so I probably read a book or something while I was doing it but the activity was listening to the music.
Last year, I bought an inexpensive FLAC player. It can do more but, it's so convoluted to use, it's really best at playing an album or a playlist. Maybe it could hop on the internet for something other than syncing its clock. It says it does some streaming thing that makes my eyes glaze over whenever I think about figuring out what that means. It's a chore to get music onto it. Managing playlists for it requires either manually adding songs from the player one by one ... or reverse engineering their not-at-all-M3U file which still has the extension M3U.
It's not for everyone. It's barely for me. But it lets me listen to the music without too much messing with it. In fact, the more messing I have to do with it, the more tedious it is to deal with.
It's more inconvenient than popping a tape in and then turning it over when the side finishes. Unless, of course, you live in 2025 and you have to first find a tape player and then find or record a tape. And then you've got just one tape. Battery will need recharging on my little FLAC player before it runs out of music on the 256GB micro SD card I've half filled.
I still haven't just listened to an album in a while even with a good book.
I think I'll do that soon. I'll let you know how it goes.
#Personal #Essay #Nostalgia #Technology #Music
from
Larry's 100
The Blacktongue Thief – Christopher Buehlman (2021)
Branded deadbeat by his thieves guild, rare of coin, but still a romantic optimist (when he's feeling lucky), protagonist Kinch Na Shannack colorfully narrates us along his macabre adventures.
What unfolds is a rollicking low fantasy adventure—more taverns and flophouses than courtly castles. Kinch picks up a motley crew, including a red wine-obsessed knight who stores giant fighting birds in her tattoos, a paraplegic witch who enchants recently deceased torsos to walk, and an assassin cat.
Magic systems and world-building are inventive but subtle, opting to start small and grow.
Ever the trickster, Kinch is a riot. Read it.

#Bookstodon #BookReview #Fantasy #Drabble #TheBlacktongueThief #CultureDrabble #ChristopherBuehlman
from
Human in the Loop

The smartphone in your pocket contains more computing power than the Apollo 11 mission computers. Yet whilst NASA needed rooms full of specialised engineers writing machine code to land humans on the moon, today's citizen developers can build functional applications using drag-and-drop interfaces whilst queuing for coffee. This transformation represents one of the most profound democratisations in human technological history, but it also raises an uncomfortable question: if everyone can code, what becomes of the craft itself?
The numbers tell a story of radical change. Gartner forecasts that by 2025, 70% of new applications developed by enterprises will utilise low-code or no-code technologies, a dramatic leap from less than 25% in 2020. The global low-code development platform market, valued at $10.46 billion in 2024, is projected to explode to $82.37 billion by 2034, growing at a compound annual growth rate of 22.92%. Meanwhile, AI-augmented development tools like GitHub Copilot have been activated by more than one million developers and adopted by over 20,000 organisations, generating over three billion accepted lines of code.
Yet beneath this seductive narrative of universal empowerment lies a deeper tension. The same forces democratising software creation may simultaneously erode the very qualities that distinguish meaningful software from merely functional code. When technical constraints vanish, when implementation becomes trivial, when everyone possesses the tools of creation, does intentionality disappear? Does architectural rigour become an anachronism? Or does the craft of software engineering simply migrate to a different, more rarefied plane where the essential skill becomes knowing what not to build rather than how to build it?
This isn't merely an academic debate. It strikes at the heart of what software means in modern civilisation. We're grappling with questions of expertise, quality, sustainability, and ultimately, meaning itself in an age of abundant creation.
The evolution of programming languages is fundamentally a story about abstraction, each generation trading granular control for broader accessibility. This progression has been a defining characteristic of software development history, a relentless march towards making the complex simple.
In the beginning, there was machine code: raw binary instructions understood directly by processors. First-generation programming languages (1GL) required programmers to think in the computer's native tongue, manipulating individual bits and bytes. Second-generation languages (2GL) brought assembly language, where mnemonic codes replaced binary strings. Yet assembly still required deep hardware knowledge and remained tied to specific processor architectures.
The true revolution came with third-generation high-level languages: FORTRAN, COBOL, C, and their descendants. These pioneering languages transformed software development, making it easier to create, maintain, and debug applications. By abstracting away hardware-specific details, developers could focus on solving problems rather than wrestling with machine code nuances. Each relatively abstract, “higher” level builds on a relatively concrete, “lower” level.
But the abstraction didn't stop there. Object-oriented programming encapsulated data and behaviour into reusable components. Web frameworks abstracted network protocols and browser differences. Cloud platforms abstracted infrastructure management. Each step made software development more accessible whilst raising new questions about what developers needed to understand versus what they could safely ignore.
Programming has always been about building layers of abstraction that make complex systems more accessible. Each major evolution has followed a similar pattern: trade some control for productivity, and open the field to more people. Low-code, no-code, and AI-augmented platforms represent the latest iteration of this ancient pattern.
Yet something feels different this time. Previous abstraction layers still required understanding underlying concepts. A Java programmer might not write assembly code, but they needed to understand memory management, data structures, and algorithmic complexity. The new platforms promise to abstract away not just implementation details but conceptual understanding itself. You don't need to understand databases to build a database-backed application. You simply describe what you want, and the platform materialises it.
This represents a qualitative shift, not merely a quantitative one. We're moving from “making programming easier” to “making programming unnecessary”. The implications cascade through every assumption about technical expertise, professional identity, and software quality.
Walk into any modern enterprise, and you'll encounter a new species of creator: the citizen developer. These aren't trained software engineers but operations managers, HR professionals, marketing analysts, and finance controllers who build the tools they need using platforms requiring no traditional coding knowledge. The statistics reveal their proliferation: 83% of enterprises with over 5,000 employees report active citizen development programmes. Gartner predicts that by 2026, developers outside formal IT departments will account for at least 80% of low-code development tool users, up from 60% in 2021.
The business case appears compelling. 62% of respondents in a 2024 survey believe citizen development significantly accelerates digital transformation. Tangible benefits include faster response times (76% of tech leaders expect this), increased solution customisation (75% anticipate this), and productivity gains (58% predict over 10% increases). Companies spend an average of 40% of their IT budget maintaining existing software; citizen development promises to redirect that spending towards innovation.
The platforms enabling this revolution have become remarkably sophisticated. Tools like Microsoft Power Apps, Mendix, OutSystems, and Bubble offer visual development environments where complex applications emerge from dragging components onto canvases. AI has accelerated this further; platforms now generate code from natural language descriptions and automatically suggest optimal database schemas.
Yet the citizen developer movement harbours profound tensions. The same speed and accessibility that make these platforms attractive also create new categories of risk. Without proper governance, low-code adoption can lead to technical debt: a hidden yet costly issue undermining long-term scalability, security, and performance. Without governance, low-code's speed can result in proliferating unmanaged apps, inconsistent practices, security gaps, and integration problems.
Consider the fundamental paradox: citizen developers succeed precisely because they don't think like traditional engineers. They focus on immediate business problems rather than architectural elegance. They prioritise working solutions over scalable systems. They solve today's challenges without necessarily considering tomorrow's maintenance burden. This pragmatism is both their strength and their weakness.
Data security remains the top concern for 44% of CIOs when asked about citizen development. Citizen developers, lacking formal security training, may inadvertently create applications with SQL injection vulnerabilities, exposed API keys, or inadequate access controls. They might store sensitive data in ways violating regulatory compliance.
Beyond security, there's the spectre of technical debt. Jacob Goerz, a technology analyst, contends that “if business users are empowered to build their own tools and can build them rapidly, we are trading one form of technical debt for another.” The debt manifests differently: proliferating applications that nobody maintains, undocumented business logic trapped in visual workflows, and integration spaghetti connecting systems in ways that confound anyone attempting to understand them later.
Gartner analyst Jason Wong notes that “anytime you add customisations via scripting and programming, you introduce technical debt into a low-code or no-code platform.” Low-code platforms immediately turn each drag-and-drop specification into code, often using proprietary languages developers may not understand. The abstraction becomes a black box, working perfectly until it doesn't.
The citizen developer revolution thus presents a Faustian bargain: immediate empowerment purchased with deferred costs in governance, security, and long-term maintainability.
If low-code platforms democratise software creation by removing manual coding, AI-augmented development tools represent something more radical: they transform coding from a human activity into collaborative dialogue between human intent and machine capability. GitHub Copilot, the most prominent exemplar, has been activated by over one million developers. Research from controlled experiments showed developers with GitHub Copilot completed tasks 55.8% faster. Engineering teams at companies like Duolingo achieved a 25% increase in developer velocity.
These aren't marginal improvements; they're transformative shifts. Developers using GitHub Copilot report being up to 55% more productive at writing code and experiencing up to 75% higher job satisfaction. Research suggests the increase in developer productivity from AI could boost global GDP by over $1.5 trillion.
Copilot integrates seamlessly with development environments, providing real-time code suggestions by understanding context and intention. It actively predicts patterns, making repetitive coding tasks significantly faster. By automating parts of quality engineering and testing processes, AI helps developers maintain high-quality code with less manual effort.
The impact varies by experience level. Studies found that less experienced developers gain greater advantages from tools like GitHub Copilot, showing promise for AI pair programmers to help people transition into software development careers. This democratising effect could fundamentally reshape who becomes a developer and how they learn the craft.
Yet AI-augmented development introduces its own paradoxes. Copilot's suggestions can be less than optimal or incorrect, especially for complex logic or edge cases, requiring developers to review and validate generated code. This creates an interesting inversion: instead of writing code and checking if it works, developers now read AI-generated code and determine if it's correct. The cognitive skill shifts from creation to evaluation, from synthesis to analysis.
This shift has profound implications for expertise. Traditional programming education emphasises understanding why code works and building mental models of program execution. But when AI generates code, what knowledge becomes essential? Do developers still need to understand algorithmic complexity if AI handles optimisation?
Some argue AI elevates developers from implementation mechanics to higher-order design thinking. Instead of sweating syntax and boilerplate code, they focus on architecture, user experience, and business logic. In this view, AI doesn't diminish expertise; it refocuses it on aspects machines handle poorly: ambiguity resolution, stakeholder communication, and holistic system design.
Others worry that relying on AI-generated code without deep understanding creates brittle expertise. When AI suggests suboptimal solutions, will developers recognise the deficiencies? There's a risk of creating developers who can prompt AI effectively but struggle to understand the systems they nominally control.
The consensus emerging from early adoption suggests AI works best as an amplifier of existing expertise rather than a replacement. Experienced developers use AI to accelerate work whilst maintaining critical oversight. They leverage AI for boilerplate generation and routine implementation whilst retaining responsibility for architectural decisions, security considerations, and quality assurance.
GitHub Copilot has generated over three billion accepted lines of code, representing an unprecedented transfer of implementation work from humans to machines. The question isn't whether AI can write code (it demonstrably can), but whether AI-written code possesses the same intentionality, coherence, and maintainability as code written by thoughtful humans. The answer appears to be: it depends on the human wielding the AI.
Amidst the democratisation narrative, a quieter but persistent voice advocates for something seemingly contradictory: software craftsmanship. In December 2008, aspiring software craftsmen met in Libertyville, Illinois to establish principles for software craftsmanship, eventually presenting their conclusions as the Manifesto for Software Craftsmanship. The manifesto articulates four core values extending beyond Agile's focus on working software:
Software craftsmanship emphasises the coding skills of software developers, drawing a metaphor between modern software development and the apprenticeship model of medieval Europe. It represents a fundamental assertion: that how software is built matters as much as whether it works. The internal quality of code, its elegance, its maintainability, its coherence, possesses intrinsic value beyond mere functionality.
This philosophy stands in stark tension with democratisation. Craftsmanship requires time, deliberate practice, mentorship, and deep expertise. It celebrates mastery that comes from years of experience, intuition distinguishing expert from novice, tacit knowledge that cannot be easily codified or automated.
The practical manifestations include test-driven development, rigorous code review, refactoring for clarity, and adherence to design principles. Craftsmen argue these practices create software that's not just functional but sustainable: systems that adapt gracefully to changing requirements, code that future developers can understand and modify, architectures that remain coherent as they evolve.
Critics accuse craftsmanship of elitism, of valuing aesthetic preferences over business outcomes. They argue “well-crafted” is subjective, that perfect code shipped late is worthless. In an era where speed determines competitive advantage, craftsmanship is a luxury few can afford.
Yet proponents counter this misunderstands the time scale of value creation. Poorly structured code might deliver features faster initially but accumulates technical debt slowing all future development. Systems built without architectural rigour become increasingly difficult to modify, eventually reaching states where any change risks catastrophic failure.
Research on technical debt in agile contexts validates this concern. The most popular causes of incurring technical debt in agile software development are “focus on quick delivery” and “architectural and design issues”. Agile methodologies use continuous delivery and adaptability to develop software meeting user needs, but such methods are prone to accumulating technical debt. The paradox emerges clearly: agility values immediate functionality over long-term code quality, which inherently encourages technical debt accrual, yet agility's iterative nature offers an ideal setting for addressing technical debt.
The craftsmanship movement articulates a vital counterpoint to pure democratisation. It insists that expertise matters, that quality exists on dimensions invisible to end-users, and that long-term sustainability requires discipline and skill.
But here's where the tension becomes most acute: if craftsmanship requires years of dedicated practice, how does it coexist with platforms promising anyone can build software? Can craftsmanship principles apply to citizen-developed applications? Does AI-generated code possess craft?
The democratisation of software creation produces an unexpected consequence: abundance without curation. When building software is difficult, scarcity naturally limits what gets built. Technical barriers act as filters, ensuring only ideas with sufficient backing overcome the implementation hurdle. But when those barriers dissolve, when creating software becomes as easy as creating a document, we face a new challenge: deciding what deserves to exist.
This is where intentionality becomes critical. Intentional architecture, as defined in software engineering literature, is “a purposeful set of statements, models, and decisions that represent some future architectural state”. The purpose of software architecture is to bring order and intentionality to the design of software systems. But intentionality operates on multiple levels: not just how we build, but why we build and what we choose to build.
The ongoing discussion in software architecture contrasts intentional architecture (planned, deliberate, involving upfront design) with emergent design (extending and improving architecture as needed). Neither extreme proves optimal; the consensus suggests balancing intentionality and emergence is essential. Yet this balance requires judgment, experience, and understanding of trade-offs, qualities that democratised development tools don't automatically confer.
Consider what happens when technical constraints vanish. A citizen developer identifies a business problem and, within hours, constructs an application addressing it. The application works. Users adopt it. Value is created. But was this the right solution? Might a different approach have addressed not just the immediate problem but a broader category of issues? Does this application duplicate functionality elsewhere in the organisation? Will anyone maintain it when the creator moves to a different role?
These questions concern intentionality at the system level, not just the code level. They require stepping back from immediate problem-solving to consider broader context, long-term implications, and architectural coherence. They demand expertise not in building things but in knowing whether things should be built, and if so, how they integrate with the larger ecosystem.
Democratised development tools excel at implementation but struggle with intentionality. They make building easy but provide little guidance on whether to build. They optimise for individual productivity but may undermine organisational coherence. They solve the “how” brilliantly whilst leaving the “why” and “what” largely unaddressed.
This creates a profound irony: the very accessibility that democratises creation also demands higher-order expertise to manage its consequences. When anyone can build software, someone must curate what gets built, ensure integration coherence, manage the proliferation of applications, and maintain architectural vision preventing organisational software from fragmenting into chaos.
The skill, then, migrates from writing code to making judgments: judgments about value, sustainability, integration, and alignment with organisational goals. It becomes less about technical implementation and more about systems thinking, less about algorithms and more about architecture, less about individual applications and more about the holistic digital ecosystem.
Intentionality also extends to the experiential dimension: not just what software does but how it feels to use, what values it embodies, and what second-order effects it creates. In an age where software mediates increasing amounts of human experience, these considerations matter profoundly.
Yet democratised development tools rarely engage with these questions. They optimise for functionality, not meaning. They measure success in working features, not in coherent experiences or embodied values.
This represents perhaps the deepest tension in democratisation: whether software reduced to pure functionality, stripped of craft and intentionality, can still serve human flourishing in the ways software created with care and purpose might. When everyone can code, the challenge becomes ensuring what gets coded actually matters.
Perhaps the dichotomy is false. Perhaps democratisation doesn't destroy expertise but transforms it, elevating craft to a different plane where different skills matter. Several threads of evidence support this more optimistic view.
First, consider historical precedent. When high-level programming languages emerged, assembly programmers worried abstraction would erode understanding and produce inferior software. They were partially correct: fewer modern developers understand processor architecture. But they were also profoundly wrong: high-level languages didn't eliminate expertise; they redirected it toward problems machines handle poorly (business logic, user experience, system design) and away from problems machines handle well (memory management, instruction scheduling).
The abstraction layers that democratised programming simultaneously created new domains for expertise. Performance optimisation moved from hand-tuned assembly to algorithm selection and data structure design. Security shifted from buffer overflow prevention to authentication architecture and threat modelling. Expertise didn't disappear; it migrated and transformed.
Current democratisation may follow a similar pattern. As implementation becomes automated, expertise concentrates on aspects machines can't easily automate: understanding stakeholder needs, navigating organisational politics, designing coherent system architectures, evaluating trade-offs, and maintaining long-term vision. These skills, often termed “soft skills” but more accurately described as high-level cognitive and social capabilities, become the differentiators.
Research on GitHub Copilot usage reveals this pattern emerging. Experienced developers leverage AI for routine implementation whilst maintaining critical oversight of architecture, security, and quality. They use AI to accelerate mechanical aspects of development, freeing cognitive capacity for conceptual challenges requiring human judgment. The AI handles boilerplate; the human handles the hard parts.
Second, consider the role of governance and platform engineering. The proliferation of citizen developers and AI-augmented tools creates demand for a new expertise category: those who design guardrails, create reusable components, establish standards, and build the platforms on which others build. This isn't traditional coding, but it requires deep technical knowledge combined with organisational understanding and system design capability.
83% of enterprises with active citizen development programmes also report implementing governance frameworks. These frameworks don't emerge spontaneously; they require expert design. Someone must create component libraries enabling consistent, secure development. Someone must architect integration patterns preventing chaos. This work demands expertise at a higher abstraction level than traditional development.
Third, craftsmanship principles adapt rather than obsolete. Well-crafted software remains superior to poorly crafted software even when created with low-code tools. The manifestation of craft changes: instead of elegant code, it might be well-designed workflows, thoughtful data models, or coherent component architectures. The underlying values (clarity, maintainability, sustainability) persist even as the medium transforms.
Evolutionary architecture, described as “the approach to building software that's designed to evolve over time as business priorities change, customer demands shift, and new technologies emerge”, is “forged by the perfect mix between intentional architecture and emergent design”. This philosophy applies equally whether implementation happens through hand-written code, low-code platforms, or AI-generated logic. The expertise lies in balancing intention and emergence, not in the mechanics of typing code.
Fourth, democratisation creates its own expertise hierarchies. Not all citizen developers are equally effective. Some produce coherent, maintainable applications whilst others create tangled messes. Expertise in wielding democratised tools effectively, in knowing their affordances and limitations, in producing quality outputs despite simplified interfaces, this becomes a skill in itself.
The elevation thesis suggests that each wave of democratisation expands the pool of people who can perform routine tasks whilst simultaneously raising the bar for what constitutes expert-level work. More people can build basic applications, but architecting robust, scalable, secure systems becomes more valuable precisely because it requires navigating complexity that democratised tools can't fully abstract away.
This doesn't mean everyone benefits equally from the transition. Traditional coding skills may become less valuable relative to architectural thinking, domain expertise, and stakeholder management. The transition creates winners and losers, as all technological transformations do.
But the thesis challenges the narrative that democratisation inevitably degrades quality or eliminates expertise. Instead, it suggests expertise evolves, addressing new challenges at higher abstraction levels whilst delegating routine work to increasingly capable tools. The craft doesn't disappear; it ascends.
If we accept that democratisation is inevitable and potentially beneficial, the critical question becomes: how do we ensure that abundant creation doesn't devolve into meaningless proliferation? How do we design for meaning rather than merely for function when everyone possesses the tools of creation?
This question connects to deeper philosophical debates about technology and human values. A philosophy of software design defines complexity as “anything related to the structure of a software system that makes it hard to understand and modify the system”, shifting focus from what software does to how it's designed for understanding and maintainability. But we might extend this further: what would it mean to design software not just for maintainability but for meaningfulness?
Meaningfulness in software might encompass several dimensions. First, alignment with genuine human needs rather than superficial wants or artificial problems. The ease of creation tempts us to build solutions searching for problems. Designing for meaning requires disciplined inquiry into whether proposed software serves authentic purposes.
Second, coherence with existing systems and practices. Software participates in ecosystems of tools, workflows, and human activities. Meaningful software integrates thoughtfully, enhancing rather than fragmenting the systems it joins.
Third, sustainability across time. Meaningful software considers its lifecycle: who will maintain it, how it will evolve, what happens when original creators move on. Can future developers understand this system? Can it adapt to changing requirements?
Fourth, embodiment of values. Software encodes assumptions about users, workflows, and what matters. Meaningful software makes these assumptions explicit and aligns them with the values of the communities it serves.
Fifth, contribution to human capability rather than replacement. The most meaningful software augments human judgment and creativity rather than attempting to eliminate them.
Achieving these dimensions of meaning requires what we might call “meta-expertise”: not just skill in building software but wisdom in deciding what software should exist and how it should relate to human flourishing. This expertise cannot be fully codified into development platforms because it requires contextual judgment, ethical reasoning, and long-term thinking that resists algorithmic capture.
The challenge facing organisations embracing democratised development is cultivating this meta-expertise whilst empowering citizen developers. Several approaches show promise: establishing centres of excellence that mentor citizen developers in system thinking and design philosophy, creating review processes evaluating proposed applications on dimensions beyond functionality, and developing shared vocabularies for discussing software quality and sustainability.
Educational institutions face parallel challenges: if coding mechanics become increasingly automated, what should computer science education emphasise? Perhaps greater focus on computational thinking divorced from specific languages, on software architecture and system design, on ethics and values in technology, on communication and collaboration.
Ultimately, designing for meaning in abundant software requires cultural shifts as much as technical solutions. We need to cultivate appreciation for restraint, for the applications we choose not to build. We need to celebrate coherence and integration as achievements equal to novel creation. We need to recognise that in a world where everyone can code, the differentiating skill becomes knowing what deserves coding and having the judgment to execute on that knowledge with care.
The anxiety underlying the question posed at the beginning (when everyone can code, does craft disappear?) rests on a false dichotomy: that democratisation and expertise exist in zero-sum competition. The evidence suggests otherwise.
Democratisation expands the base of people who can create functional software, solving the mismatch between demand for software solutions and supply of professional developers. Gartner's prediction that 70% of new applications will use low-code or no-code technologies by 2025 reflects this reality: given ever-increasing demand for software solutions, it will eventually become impossible to rely only on expert software engineers.
But democratisation also creates new demand for expertise. Someone must build the platforms that democratise creation. Someone must govern their use. Someone must maintain architectural coherence across proliferating applications. Someone must make high-level design decisions that platforms can't automate. The nature of expertise shifts, but its necessity persists.
Moreover, democratisation and craftsmanship can coexist in symbiosis. Professional developers can focus on complex, critical systems where quality and sustainability justify the investment in expertise. Citizen developers can address the long tail of niche needs that professional developers couldn't economically serve. The platforms can incorporate craftsmanship principles (security best practices, accessibility guidelines, performance optimisation) as defaults.
The consensus emerging from low-code adoption experiences suggests that low-code is not a silver bullet to solve technical debt, and maintaining the highest levels of quality and performance still requires expert involvement. Hybrid models work best: platforms for routine needs, professional development for complex systems, and experts providing governance and guidance across both.
Intentionality and architectural rigour don't erode in this model; they become more important precisely because they can't be fully automated. As implementation mechanics get abstracted away, the aspects requiring human judgment (what to build, how to design for evolution, how to balance competing concerns) gain prominence. The craft elevates from syntax and algorithms to strategy and system design.
The real risk isn't that democratisation destroys expertise but that we fail to adapt our institutions, education, and professional development to cultivate the new forms of expertise that democratisation demands. If we continue training developers primarily in coding mechanics whilst neglecting system design, stakeholder communication, and architectural thinking, we'll create a mismatch between skills and needs.
The evidence from GitHub Copilot adoption is instructive: productivity gains are largest when AI augments existing expertise rather than replacing it. The same pattern likely applies to low-code and no-code platforms. They amplify capability; they don't replace judgment.
The democratisation of software creation represents one of the most consequential technological shifts of our era. The numbers are staggering: markets growing at 20% to 30% annually, 80% of development eventually occurring outside traditional IT departments, AI-generated billions of lines of code, productivity gains exceeding 50%. These changes are neither reversible nor ignorable.
But the question posed at the beginning reveals a deeper anxiety about meaning and value in an age of technological abundance. If building software becomes trivial, what distinguishes good software from bad? If technical barriers vanish, what prevents proliferation without purpose? If anyone can create, how do we ensure what gets created actually matters?
The answer emerging from experience, research, and philosophical reflection is nuanced. Craft doesn't disappear; it transforms. The skills that matter shift from implementation mechanics toward system design, from coding syntax toward architectural thinking, from building individual applications toward maintaining coherent ecosystems. Intentionality becomes more critical precisely because it can't be automated. The ability to decide what not to build, to design for meaning rather than mere function, to balance immediate needs with long-term sustainability, these capabilities distinguish expertise in the democratised era.
This transformation requires rethinking professional identity, restructuring education, redesigning organisational processes, and cultivating new forms of meta-expertise. It demands that we resist the seduction of building simply because we can, that we develop cultural appreciation for restraint and coherence, that we design governance systems ensuring democratisation doesn't devolve into chaos.
The software craftsmanship manifesto's insistence on well-crafted software, steadily adding value, professional community, and productive partnerships becomes more relevant, not less, in the democratised era. But craftsmanship must adapt: from code elegance to system coherence, from individual mastery to collaborative governance, from artisanal creation to platform architecture.
The promise of democratisation isn't that everyone becomes an expert software engineer (they won't and needn't). The promise is that people can solve their own problems without waiting for scarce expert attention, that organisations can respond faster to opportunities, that the gap between idea and implementation narrows. But realising this promise without creating unsustainable messes requires expertise at higher abstraction levels: in platform design, governance frameworks, architectural vision, and the cultivation of intentionality even in simplified creation environments.
We're living through a grand experiment in what happens when software creation tools become abundant and accessible. Early results suggest both tremendous opportunity and real risks. The outcome depends on choices we make now about how to structure these tools, educate their users, govern their outputs, and define what software excellence means in contexts where everyone can code.
The craft of software engineering isn't disappearing. It's elevating to a plane where the essential skills are knowing what deserves building, designing systems that hang together coherently, embedding quality and sustainability into the platforms everyone uses, and ultimately, creating software that serves human flourishing rather than merely executing functions. When everyone can code, the real expertise lies in ensuring what gets coded actually matters.
That's a craft worth cultivating, and it's more necessary now than ever.
Precedence Research. (2024). “Low-Code Development Platform Market Size to Surpass USD 82.37 Bn by 2034.” https://www.precedenceresearch.com/low-code-development-platform-market
Gartner. (2021-2024). “Low-Code and No-Code Development Technologies Forecast.” Multiple reports and press releases. https://www.gartner.com/en/newsroom/press-releases/2021-11-10-gartner-says-cloud-will-be-the-centerpiece-of-new-digital-experiences
Kissflow. (2024). “The 2024 Citizen Development Trends Report.” https://kissflow.com/citizen-development/citizen-development-trends-report/
Kissflow. (2024). “Kissflow launches 2024 Citizen Development Trends Report.” PR Newswire, October 2024. https://www.prnewswire.com/news-releases/kissflow-launches-2024-citizen-development-trends-report-302258507.html
Peng, S., et al. (2023). “The Impact of AI on Developer Productivity: Evidence from GitHub Copilot.” arXiv:2302.06590. https://arxiv.org/abs/2302.06590
GitHub. (2023). “Research: quantifying GitHub Copilot's impact on developer productivity and happiness.” The GitHub Blog. https://github.blog/news-insights/research/research-quantifying-github-copilots-impact-on-developer-productivity-and-happiness/
GitHub. (2023). “The economic impact of the AI-powered developer lifecycle and lessons from GitHub Copilot.” The GitHub Blog. https://github.blog/news-insights/research/the-economic-impact-of-the-ai-powered-developer-lifecycle-and-lessons-from-github-copilot/
GitHub Customer Stories. “How Duolingo uses GitHub.” https://github.com/customer-stories/duolingo
TechCrunch. (2025). “GitHub Copilot crosses 20M all-time users.” 30 July 2025. https://techcrunch.com/2025/07/30/github-copilot-crosses-20-million-all-time-users/
Communications of the ACM. (2024). “Measuring GitHub Copilot's Impact on Productivity.” https://cacm.acm.org/research/measuring-github-copilots-impact-on-productivity/
Manifesto for Software Craftsmanship. (2009). Libertyville, Illinois meeting, December 2008; published March 2009. https://manifesto.softwarecraftsmanship.org/
Wikipedia. “Software craftsmanship.” https://en.wikipedia.org/wiki/Software_craftsmanship
InfoQ. (2009). “Software Craftsmanship Manifesto: A Call to Arms.” March 2009. https://www.infoq.com/news/2009/03/software_craftsmanship/
Ramač, R., et al. (2024). “Analyzing the concept of technical debt in the context of agile software development: A systematic literature review.” Information and Software Technology, ScienceDirect. https://www.sciencedirect.com/science/article/abs/pii/S0950584916302890
Alzaghoul, E., & Bahsoon, R. (2024). “Technical debt and agile software development practices and processes: An industry practitioner survey.” Information and Software Technology, ScienceDirect. https://www.sciencedirect.com/science/article/pii/S0950584917305098
The Open Group. “Intentional Architecture.” The Open Group Agile Architecture Standard. https://pubs.opengroup.org/architecture/o-aa-standard/intentional-architecture.html
Rossini, S. (2024). “Agile Architecture Part.2: Intentional, Emergent & Evolutionary Architectures.” Medium, September 2024. https://medium.com/@stefano.rossini.mail/agile-architecture-intentional-emergent-evolutionary-architectures-da77905098fc
Muthukumarana, D. “Balancing Emergent Design and Intentional Architecture in Agile Software Development.” Medium. https://dilankam.medium.com/balancing-emergent-design-and-intentional-architecture-in-agile-software-development-889b07d5ccb9
CIO Dive. “Low code offers a glimmer of hope for paying off technical debt.” https://www.ciodive.com/news/no-code-codeless-low-code-software-development-unqork/640798/
Merak Systems. (2019). “Technical Debt – The promise and peril of low-code applications.” By Jacob Goerz, 14 October 2019. https://www.meraksystems.com/blog/2019/10/14/technical-debt-the-promise-and-peril-of-low-code-applications.html
Wong, J. (Gartner). Referenced in multiple sources regarding low-code technical debt and customizations. Gartner analyst profile: https://www.gartner.com/en/experts/jason-wong
Quixy. “Game-Changing Top 60 No-Code Low-Code Citizen Development Statistics.” https://quixy.com/blog/no-code-low-code-citizen-development-statistics-facts/
IT Brief Asia. (2024). “83% of firms confirm active citizen development programs – report.” https://itbrief.asia/story/83-of-firms-confirm-active-citizen-development-programs-report
Stack Overflow. (2024). “AI | 2024 Stack Overflow Developer Survey.” https://survey.stackoverflow.co/2024/ai
Intelligent CIO North America. (2023). “AI developer productivity could boost global GDP by over $1.5 trillion by 2030.” 10 July 2023. https://www.intelligentcio.com/north-america/2023/07/10/ai-developer-productivity-could-boost-global-gdp-by-over-1-5-trillion-by-2030/

Tim Green UK-based Systems Theorist & Independent Technology Writer
Tim explores the intersections of artificial intelligence, decentralised cognition, and posthuman ethics. His work, published at smarterarticles.co.uk, challenges dominant narratives of technological progress while proposing interdisciplinary frameworks for collective intelligence and digital stewardship.
His writing has been featured on Ground News and shared by independent researchers across both academic and technological communities.
ORCID: 0009-0002-0156-9795 Email: tim@smarterarticles.co.uk
from
Roscoe's Story
In Summary: * Happy to get a phone call early this afternoon from the nurse who is my contact / intake person as I try to get into the clinical trials exploring alternate treatment for the wet macular degeneration condition in my right eye. She told me not to give up on them. She cancelled my previosly scgeduled apt. tomorrow morning with my Retina doc when we were going to start standard treatment. She's trying to schedule my first clinical trial treatment for Thursday or Friday afternoon of this week, or Monday morning of next week.
Prayers, etc.: * My daily prayers.
Health Metrics: * bw= 216.38 lbs. * bp= 140/83 (63)
Exercise: * kegel pelvic floor exercise, half squats, calf raises, wall push-ups
Diet: * 06:20 – 2 HEB Bakery cookies, 1 banana * 07:00 – cottage cheese and applesauce * 08:45 – fried chicken, biscuit, 3 boiled eggs * 10:50 – 2 HEB Bakery cookies * 11:45 – pork chops * 12:45 – pumpkin pie * 15:15 – 1 fresh apple
Activities, Chores, etc.: * 05:00 – listen to local news, talk radio * 05:50 – bank accounts activity monitored * 06:20 – read, pray, listen to news reports from various sources * 12:30 to 13:15 – watch old game shows and eat lunch at home with Sylvia. * 14:45 – listening to relaxing music, quietly reading * 17:30 – listening to The Joe Pags Show * 18:00 – tuned into my college basketball of the night, Milwaukee Wisconsin Panthers at Indiana Hoosiers
Chess: * 11:05 – moved in all pending CC games
from Douglas Vandergraph
You can mute people in real life — it’s called boundaries. And sometimes, that’s exactly what God wants you to do. 💫
If you’ve ever felt like you’re constantly giving, endlessly listening, or living on emotional fumes — this message is for you.
In his powerful talk, Douglas Vandergraph unpacks how Jesus set boundaries, how you can protect your peace without guilt, and how muting the world helps you hear Heaven louder.
Watch the full message: How to Guard Your Peace by Muting the World
Some people think boundaries are selfish. But boundaries aren’t bars — they’re bridges to peace.
When you finally learn to say no without shame, you start walking in freedom that feels like breathing again.
God didn’t design you to carry everyone’s burdens all the time. Even Jesus — the most compassionate soul to walk the earth — took time to rest, recharge, and retreat.
In Luke 5:16, we’re told, “Jesus often withdrew to lonely places and prayed.” That word often matters. It wasn’t an emergency break — it was a rhythm of life.
Boundaries don’t break relationships; they rescue them. They keep love alive by preventing burnout. They guard the heart that keeps giving.
If you’ve ever felt guilty for setting a limit, welcome to humanity. Guilt is one of the enemy’s favorite tricks.
It whispers: “If you were truly loving, you’d always say yes.” But Jesus didn’t.
He said no to manipulation (Mark 8:11-13). He said no to distraction (Luke 4:42-44). He said no to demands that didn’t align with His mission (Mark 1:35-38).
He loved deeply — but strategically.
As Crosswalk.com points out, boundaries in Scripture aren’t rejection; they’re direction. They point your “yes” back toward your calling.
So next time guilt knocks, remember: your peace is not a sin, it’s a stewardship.
Love is holy. But love without boundaries becomes martyrdom.
If you’re constantly drained, constantly saying yes, constantly rescuing — you’re not walking in Christ’s example, you’re walking in emotional exhaustion.
Jesus loved perfectly, yet He didn’t heal everyone. He didn’t fix every problem. He didn’t apologize for taking rest.
Real love isn’t about overextending — it’s about obeying.
When you stop mistaking exhaustion for holiness, you finally give God space to refill you. As GotQuestions.org reminds us, even the Savior slept through storms because His rest was trust in motion.
Jesus showed us that peace is not found in people’s approval but in the Father’s presence.
Modern psychology finally caught up with Scripture.
According to the American Psychological Association, boundaries lower stress, prevent burnout, and foster emotional stability.
When you slow down, your nervous system resets, your cortisol levels drop, and your clarity returns. That’s not just neuroscience — it’s divine design.
Psalm 46:10 whispers: “Be still and know that I am God.” Science calls it rest; Scripture calls it revelation.
Stillness heals your body and opens your ears to Heaven.
Somewhere along the way, we equated busyness with faithfulness. But rest is holy.
The Creator of the universe rested — not because He was tired, but because He was teaching us rhythm.
Focus on the Family notes that rest restores the soul and renews compassion. When you rest, you return to your relationships with replenished grace.
So next time someone makes you feel lazy for slowing down, remember: you’re following God’s example, not theirs.
The world shouts; Heaven whispers. That’s why God speaks in silence — not because He’s hiding, but because He’s holy.
When Elijah fled to the wilderness, he expected God in the earthquake or fire. But God came in a gentle whisper (1 Kings 19:12).
He still does.
The problem isn’t that God stopped speaking — it’s that we stopped muting the world.
When you create space for quiet, you don’t lose connection; you find communion. Boundaries turn down the volume so Heaven can turn up the voice.
Proverbs 4:23 commands:
“Above all else, guard your heart, for everything you do flows from it.”
That verse isn’t poetic advice — it’s spiritual strategy. “Guard” in Hebrew (nāṣar) means to keep, to preserve, to protect from danger.
You are the gatekeeper of what enters your inner world.
If your heart is the wellspring of life, then boundaries are the fence around the well. Without them, anything toxic can flow in and poison what God planted.
Guarding your heart is guarding your destiny.
Satan loves to weaponize compassion. He tells believers, “Real Christians never say no.”
But unchecked compassion leads to compromise.
Jesus loved Judas — but He didn’t stop Judas from leaving the table. He loved the rich young ruler — but He didn’t chase him down. He loved the Pharisees — but He didn’t bow to their opinions.
Real compassion empowers others; false compassion enslaves you.
Boundaries help you tell the difference.
Maybe you’ve been there — exhausted, numb, or spiritually disconnected. You gave everything and got nothing left.
Here’s the good news: peace can be rebuilt.
Admit to God that your boundaries were broken.
You tried to play Savior. Let Jesus be Jesus again.
Even warriors sleep.
Not everyone deserves equal access to your energy.
Praise resets perspective.
When you protect your inner life, God begins to pour again.
Isaiah 30:15 says:
“In repentance and rest is your salvation, in quietness and trust is your strength.”
That’s your recovery roadmap.
Communicate clearly. Silence breeds resentment; clarity breeds peace.
Be consistent. Boundaries lose power when they fluctuate.
Pray before you post, text, or react. God may want you silent, not reactive.
Create margin. Schedule rest like a sacred appointment.
Let go of emotional debt. You’re not responsible for everyone’s healing.
Surround yourself with peace-minded people. As BibleGateway reminds us: “Walk with the wise and become wise.”
Celebrate progress. Every “no” that honors God is a victory for your peace.
Jesus lived in rhythm: Engage — Withdraw — Engage again.
He poured out, then pulled back.
He fed five thousand, then fled to the mountain. He taught the crowds, then took a boat to solitude. He served, then He slept.
That’s not avoidance — that’s alignment.
If even the Son of God operated in divine rhythm, why do we believe endless activity proves faith?
Boundaries are the tempo of obedience.
Sometimes setting boundaries hurts. You might lose friends, opportunities, or comfort.
But what if what you’re losing isn’t meant to stay?
Abraham had to leave his homeland. Moses had to leave Pharaoh’s palace. Jesus had to leave Nazareth’s familiarity.
Boundaries often precede breakthroughs.
Don’t mourn every closed door — some doors close because Heaven just upgraded your address.
Following God will occasionally mean disappointing people.
But if you always choose comfort over calling, you’ll miss your destiny.
As Paul said in Galatians 1:10,
“Am I now trying to win the approval of men, or of God? … If I were still trying to please men, I would not be a servant of Christ.”
You can’t follow Christ and crowd approval at the same time. Boundaries clarify who you serve.
A holy “no” is one of the most anointed words you can speak.
It’s the word that guards marriages, protects callings, and preserves sanity. It’s the word that tells anxiety, you don’t live here anymore.
Jesus used “no” to protect His mission. You can use “no” to protect your mind.
When said in love, “no” becomes an act of worship — because it keeps God first.
Boundaries are not just personal; they’re generational.
When parents model healthy limits, children learn self-control and respect. When spouses honor one another’s space, intimacy deepens. When leaders rest, teams thrive.
Peace multiplies through example.
Your boundary might be the breakthrough your family has prayed for.
When you finally silence the chaos, you start to hear whispers like these:
“You don’t have to prove yourself.” “You’re allowed to rest.” “You are loved even when you’re silent.” “Peace is your inheritance.”
Those are the words Heaven has been trying to say all along.
Boundaries are how you tune the frequency.
You’ll notice something strange after setting boundaries — some people won’t understand. They were addicted to your accessibility.
That’s okay.
You’re not alone; Jesus was misunderstood, too.
He left crowds at their peak, walked away from arguments mid-sentence, and even went to the cross while others demanded proof.
Choosing peace may isolate you temporarily, but it sanctifies you eternally.
Every time you mute the world, Heaven increases your clarity. What once confused you starts making sense. You stop striving and start sensing.
Peace becomes not just a feeling — it becomes a form of discernment. The calmer you are, the clearer you hear.
Philippians 4:7 promises that peace guards your heart and mind. That word guards means peace itself becomes a soldier around your soul.
When you protect peace, peace protects you.
Lord, teach me to set boundaries that honor You. Help me say yes with wisdom and no with peace. Mute every voice that drowns out Yours. Restore what chaos has taken. Let my rest become my revelation, and my peace become my power. In Jesus’ name, Amen.
Friend, God never asked you to live drained — He asked you to live devoted.
When you protect your peace, you’re protecting your purpose. When you learn to mute the world, you make room for miracles.
Every boundary built in love becomes a bridge to Heaven’s voice.
So step back when you must. Rest when you’re weary. Say no when it’s holy.
And listen — because in the quiet, Heaven still speaks your name.
Sincerely, Douglas Vandergraph
Watch Douglas Vandergraph’s inspiring faith-based videos on YouTube.
Support his ministry at Buy Me a Coffee.
Hashtags: #GuardYourPeace #ChristianBoundaries #FaithJourney #JesusTeachesPeace #SpiritualRest #DouglasVandergraph #FaithOverNoise #BoundariesAndBlessings #PeaceInChrist
from
Roscoe's Quick Notes

Listening now to my college basketball of the night, Milwaukee Wisconsin Panthers at Indiana Hoosiers.
And the adventure continues
from Douglas Vandergraph
There are moments in life when the world feels too heavy, when your spirit is too weary to speak, and even prayer feels impossible. You stare at the ceiling, and words just won’t come. But somehow, you keep standing. Somehow, the storm doesn’t swallow you whole.
Have you ever wondered why?
Maybe — just maybe — someone whispered your name in prayer when you couldn’t pray for yourself.
Watch the full message here. This message is one of the most powerful reminders you’ll ever hear about faith, loyalty, and divine connection — the unseen threads that hold your life together when everything else is falling apart.
📖 “The Lord restored Job’s fortunes when he prayed for his friends.” – Job 42:10
This single verse reveals one of the most extraordinary spiritual laws in Scripture — that breakthrough often begins when we stop focusing on our pain and start interceding for others.
Job was stripped of everything — wealth, health, reputation, even family. But when he prayed for his friends — the very ones who misunderstood him — God stepped in. Heaven moved. Restoration began.
That wasn’t coincidence. It was divine cause and effect.
According to Bible Hub Commentary, Job’s healing was inseparably linked to his act of forgiveness and intercession. In turning his heart outward, he aligned himself with the nature of God — who intercedes for humanity daily.
It’s the same with us. When someone whispers your name in prayer, heaven hears. When you lift another’s name in love, heaven responds.
Faith is more than belief — it’s a lifeline. It’s what carries us when we cannot carry ourselves.
When your knees buckle under the weight of life’s battles, faith steps in — often through the voice of another. Someone’s faith sustains you when your own is fading.
The Apostle Paul urged believers to “pray without ceasing” (1 Thessalonians 5:17) and to “carry each other’s burdens” (Galatians 6:2). These are not mere platitudes — they are divine blueprints for survival.
According to Christianity.com, intercessory prayer is “one of the most profound expressions of faith,” because it embodies Christ’s heart. It means standing between someone and their storm — believing God’s promises even when they cannot.
That’s the faith that moves mountains. That’s the faith that kept you alive when everything else tried to destroy you.
Loyalty is love that refuses to give up. It’s what happens when compassion meets endurance.
Job didn’t just pray for anyone — he prayed for the friends who criticized and condemned him. They misjudged his suffering, accused his faith, and questioned his integrity. Yet Job still interceded for them.
That’s loyalty.
Loyalty in prayer says, “Even if you don’t deserve it, I’ll still stand in the gap for you.” It’s love that transcends fairness.
Jesus embodied this loyalty on the cross:
“Father, forgive them, for they do not know what they are doing.” – Luke 23:34
When you pray for someone who hurt you, you’re reflecting God’s own heart. And when someone prays for you despite your flaws, they’re acting as the hands and heart of Christ.
According to StudyLight Commentary, Job’s intercession “signaled the moment God turned captivity into freedom.” Loyalty didn’t just restore Job’s friends — it restored Job himself.
That’s how powerful love-driven loyalty can be.
When someone whispers your name before God, it’s not just an act of kindness. It’s a divine transaction. A sacred connection forms — between your soul, their faith, and God’s power.
As Hosanna Revival Blog beautifully notes, “When we pray deeply for others, our hearts and emotions connect on a personal level with the heart and emotions of the Father.”
That’s divine connection — invisible, but unbreakable.
It’s what ties you to people you haven’t met, churches you’ve never visited, and believers around the world who are praying for someone just like you right now.
Prayer transcends geography and time. It’s love in motion, woven into eternity.
Sometimes the tears won’t stop, and the words won’t come. Your faith feels broken. Your hope runs dry.
That’s when God stirs someone else. He taps a friend’s shoulder at midnight, nudges a mother awake, or burdens a stranger’s heart with your name.
Romans 8:26 reminds us:
“The Spirit helps us in our weakness. We do not know what we ought to pray for, but the Spirit Himself intercedes for us through wordless groans.”
The Spirit often moves through people. Someone else’s heart aches for you, and they pray what you cannot.
Maybe that’s why you’re still standing. Maybe that’s why you didn’t give up. Because someone somewhere answered heaven’s call to pray.
“The Lord restored Job’s fortunes when he prayed for his friends.” – Job 42:10
This single sentence hides a divine law: restoration follows intercession.
Let’s unpack that truth:
PhraseMeaningApplication“The Lord restored…”God initiates every true restoration.You can stop striving and start trusting — He will restore.“…Job’s fortunes”Represents total renewal — emotional, relational, material, and spiritual.God restores more than possessions; He restores peace and purpose.“…when he prayed for his friends.”Restoration was triggered by compassion, not complaint.Your breakthrough may begin when you bless the very people who hurt you.
According to Enter the Bible, Job received “double restitution” — a biblical symbol of perfect restoration. His act of prayer unlocked heaven’s abundance.
And the same principle applies today: Your deliverance may be hidden in someone else’s name.
A whispered prayer doesn’t die. It travels. It echoes. It creates ripples that reach generations.
Maybe your grandmother prayed for your future before you were born. Maybe a teacher prayed for you when you lost your way. Maybe a friend prayed you through a storm you didn’t even know was raging.
Every whisper counts.
Crosswalk.com teaches that intercession “aligns the believer’s heart with God’s compassion, allowing His purposes to flow into the lives of others.”
When someone prayed for you, they opened a portal of grace. You may not have seen it, but heaven responded.
If someone prayed you through your valley, you now carry the torch.
You are called to be a whisperer for someone else — to stand in the spiritual gap.
Bitterness blocks blessing. Forgiveness releases it. Job’s turning point came when he prayed for his critics.
Don’t wait until you’re strong — strength comes through prayer.
Name people. Speak restoration. Call out their future as if it’s already unfolding.
Document every answered prayer — it builds faith and reminds you how God works through intercession.
Modern science has begun to acknowledge what believers have always known — prayer changes things.
A study in the Journal of Behavioral Medicine found that people who prayed for others regularly experienced significantly lower stress and higher emotional well-being.
Another study from Harvard Health Publishing found that faith-based prayer “activates regions of the brain linked to compassion and emotional regulation,” promoting resilience and peace during adversity. (Harvard Health)
Even secular research can’t ignore it: intercession strengthens both the one praying and the one being prayed for. It’s the spiritual economy of heaven — nothing poured out in love ever returns empty.
Revelation 5:8 describes golden bowls in heaven “full of incense, which are the prayers of the saints.” That means not one word you or anyone has ever prayed in faith is wasted.
Every whisper is sacred incense, rising before God’s throne.
Someone’s prayer for you might have been stored there for years, waiting for God’s appointed moment to release it. You’re walking in answered prayers you never heard.
Before Job prayed, he was trapped in loss and despair. After he prayed, he was free — not because his circumstances instantly changed, but because his heart did.
He forgave. He prayed. He loved beyond offense.
That shift moved heaven.
Many Bible scholars describe Job 42 as a “spiritual reversal” — the moment despair transformed into destiny. (Working Preacher)
When you pray for others, that same reversal happens in you. Your pain finds purpose. Your loss finds meaning.
A woman once shared that during a season of grief, she couldn’t pray. Her husband had died suddenly, and she could barely breathe, let alone believe.
Months later, she discovered her church’s prayer team had been meeting every morning at sunrise — lifting her name before God, day after day.
“I thought I survived on my own,” she said through tears. “But now I know it was their prayers carrying me.”
That’s the unseen ministry of intercession. That’s what happens when loyalty meets faith. That’s how heaven holds you when you can’t hold yourself.
When believers commit to intercession, entire communities change. Churches grow stronger. Marriages heal. Addictions break. Hope returns.
Intercessory prayer is the unseen infrastructure of revival.
According to Desiring God, “Intercession is not optional for the church — it’s the bloodstream of our faith.”
When people pray for one another, they become conduits for God’s presence. The result isn’t just personal peace — it’s societal transformation.
Intercession is also warfare. It’s where the believer enters the unseen battle and says, “Not today, Satan.”
Ephesians 6:12 reminds us that our struggles are not against flesh and blood but against spiritual forces. Prayer is the weapon that disarms the enemy.
When someone prayed for you, they weren’t just offering comfort — they were fighting hell itself for your future. And when you pray for others, you do the same.
Heaven doesn’t respond to volume — it responds to faith. You don’t need eloquent words or long speeches. Sometimes all it takes is a whisper:
“Lord, remember them.” “Father, protect her.” “Jesus, give him strength.”
That’s enough to move the heart of God.
Lord, Thank You for those who whispered my name when I couldn’t speak. Thank You for every unseen intercessor who fought for my soul. Restore them abundantly. Bless those who bless others. Teach me to become a whisperer — one who carries others in love and loyalty. Let every prayer I speak echo Your heart, and let my life become an answer to someone’s cry. In Jesus’ name, Amen.
You’re standing today because someone prayed. They stood yesterday because someone prayed for them. And tomorrow, someone else will stand because you prayed.
That’s the chain of grace. That’s the power of whispered prayer.
Job’s story shows us that the greatest miracles often begin in the quietest moments.
So whisper someone’s name. Be the prayer that changes everything. Be the reason someone still stands tomorrow.
Watch Douglas Vandergraph’s inspiring faith-based videos on YouTube.
Support this ministry and help spread God’s Word by buying a cup of coffee.
#Faith #Intercession #Job4210 #DivineRestoration #ChristianMotivation #PrayerChangesThings #SpiritualConnection #Hope #Inspiration #DouglasVandergraph #Encouragement #BibleStudy #ChristianFaith #Healing #Restoration #Love
from
The happy place
Hello again it’s me!
I’m not actually a fitness weapon, yet.
I am a DOG LOVER!
from
Café histoire

Image d’illustration générée par Perplexity
Pour Mark Humphries, sur Generative History et professeur d’Histoire à l’Université Wilfrid Laurier (Canada), nous devons enseigner à nos élèves quand utiliser l'IA, quand l'éviter et comment en tirer le meilleur parti, sans prétendre qu'elle n'existe pas.
Il nous interpelle notamment de la manière suivante :
So how can we simultaneously reject AI while also claiming to prepare students to live, work, and think critically in such a world? If we want our students to take us seriously and learn some of the things we are trying to teach them about critical thinking, they need to be able to trust that we are honest brokers who offer knowledge and ideas that are grounded in reality. I don’t think I would want to argue that while doctors can use AI to help improve diagnostics and admissions decisions, a history student can’t use it to strengthen the wording of their thesis statement or help understand obscure terminology in a primary source.
Traduction :
Alors, comment pouvons-nous à la fois rejeter l'IA et prétendre préparer les étudiants à vivre, travailler et penser de manière critique dans un tel monde ? Si nous voulons que nos étudiants nous prennent au sérieux et apprennent certaines des choses que nous essayons de leur enseigner sur la pensée critique, ils doivent pouvoir nous faire confiance et croire que nous sommes des intermédiaires honnêtes qui leur offrons des connaissances et des idées fondées sur la réalité. Je ne pense pas vouloir affirmer que si les médecins peuvent utiliser l'IA pour améliorer leurs diagnostics et leurs décisions d'admission, un étudiant en histoire ne peut pas l'utiliser pour renforcer la formulation de sa thèse ou pour aider à comprendre la terminologie obscure d'une source primaire.
En conséquence, Mark Humphries propose d’utiliser l’IA peut faire des choses utiles pour les historiens (transcription, traduction, synthèse, édition et indexation, entre autres). Cela nous libère ainsi du temps pour développer la capacité de penser de manière critique aux sources, de construire des arguments fondés sur des preuves et de naviguer dans des informations complexes. Ces compétences sont plus précieuses que jamais pour nos étudiant·es et nous-mêmes.
Cet article a suscité une réponse de Mack Penner, chercheur postdoctoral au département d'histoire de l'Université de Calgar, et Edward Dunsworth, professeur agrégé au Département d’histoire et d’études classiques de l’Université McGill et membre du collectif éditorial d’Active History sur Active History.
Ils s’opposent à l’inéluctabilité de l’hégémonie de l’IA générative. Pour eux, à l’échelle des sociétés humaines, presque rien n’est inévitable.
Les ordres sociaux et politiques, les environnements, la technologie, la culture, et bien d’autres choses sont le résultat d’actions et d’accidents passés, conditionnés par les circonstances de la journée. Les choses n’ont pas toujours été comme elles sont maintenant, et nos attentes pour l’avenir, aussi bien informés soient-elles, ne correspondront pas nécessairement à la réalité future. (traduction)
Dès lors, ils insistent sur la possibilité d'un avenir centré sur l'humain et veulent modéliser pour les élèves le refus du battage médiatique autour de l’IA et leur montrer tout ce qu’ils ont à gagner en se penchant sur un travail intellectuel difficile, car lorsqu'ils utilisent l'IA, les étudiants l'utilisent comme un raccourci, un gain de temps, un réducteur de travail. Ils n’utilisent pas, dans l’ensemble, l’IA de manière réfléchie ou minimale pour augmenter leur pensée et leur écriture.
L’article de Mark Humphries : Steering a Middle Course on AI in the History Classroom, publié également sur Active History.
L’article de Mack Penner et Edward Dunsworth:, Relevance and Resistance: Steering a Critical Course on AI
Tags : #AuCafé #Histoire #IAgénérative #humanitésnumériques
from
The happy place
I’ve weaponised my fitness!
Do you know what I mean?
Like?
What pearls of wisdom shall I share today?
Do you ever have the feeling that you’ve forgotten something important, like a dog?
Or your keys?
Or birthdays?
Sometimes I’ve got ten thousand thoughts up in the head!! Sometimes I forget stuff I do!!
It’s really crowded up there in the brain!! I forget every day, so I write my thoughts down or else they will be lost, maybe forever!!
🧚 🧚♀️ 🧚♂️ 🧚 🧚♀️ 🧚♂️
it’s like a lasagna in the head.
This reminds me of this line of text from Pistolvania (Shuko remix is the best version) by Vinnie Paz:
[…]
But if you disrespect my mother or […] And the 50 Cal make your Face look like spaghetti look at this fetti Look at all this beautiful shit A south Philly scumbag wearing Gucci and shit It's over!
Do you know this feeling? Can you relate to this?
Ok I lost my train of thought now.
But the train ride continued off rail
Because it’s not an actual train, it’s a figure of speech.
I would’ve pulled the lever.
Because passivity is my arch enemy.
from
culturavisual.cc

En mi trayecto de rebuscar en el catálogo fotográfico personal, hoy rescato para el blog una serie de fotos tomadas con una Polaroid SX70, que tras sufrir varios avatares y reparaciones, acabó vendida a buen precio. La probé una temporada con algunos carretes de película, pero finalmente decidí que la Polaroid no era para mí y mi forma de trabajar con las imágenes. Las fotos están tomadas en un paraje en el que he pasado muchos días de mi infancia y que pertenece a mi familia, y en el que, ya de más mayor, encontré un espacio para la experimentación artística, gracias a la soledad y aislamiento que lo acompaña. Conozco todos los árboles del pequeño recinto, y me apasiona explorarlos. Aquí grabé gran parte de los trabajos desarrollados durante mi formación en la Licenciatura de Bellas Artes, reconectando mi infancia con mi juventud.
Tras la muerte de mi padre, el espacio ha dejado de interesarme, por estar ligado a demasiados recuerdos, y no he vuelto a desarrollar más fotos ni trabajos sobre él.





#fotos
I had some obscene levels of clutter that needed to be dealt with in my office. Mainly stray screws, electrical components, and other random stuff. A lot of them inevitably found their way into this set of drawers.

They used to be sitting on top of my desk before I put up the Multiboard setup, but now I didn’t really have a place for them so they’ve just been sitting in the floor away from everything waiting to get emptied. I figured now was as good a time as any to take care of that.

I went through and dumped out every single drawer. I did the same thing with the random stuff sitting in my toolbox (organizing this thing is on my to-do list, but that’s gonna be a lot easier now that I’ve cleaned out all the screws and stuff).

In the end, a lot of junk found its way onto my desk.

I did what I could to organize it into piles.

And from here it got a lot easier to categorize things to figure out where they were going to end up. I ended up with a basic list: Machine screws, drywall screws, drywall anchors, nuts, washers, electrical components, rubber, fasteners, printer maintenance, magnets, and sanding.
The plan was to make only a handful of drawers for the Multiboard; I was limited to one column and if the drawers are too high up they’re not very useful. I measured and determined that I’d have room for 8 rows.

I spent a lot of time printing Multibin shells for the drawers. Two 4x3x2, four 4x3x1. It was really hard to pin these things together because the part that slots between them was experiencing a lot of friction. I decided to use some keycap lubricant I had lying around (I double-checked that it wouldn’t turn the part brittle first).


This actually worked pretty well.

For the drawers themselves, I figured the two larger drawers would be good for dumping bulk stuff into, but the smaller ones would need further organization. There are ways of subdividing the standard Multibin drawers, but I like Gridfinity’s way of doing things and wanted to have a Gridfinity grid within the drawers. This didn’t seem to exist, but it was easy enough to merge the models in Blender myself.

That said, I did actually manage to mess it up the first time. I set the Z-axis on the Gridfinity grid too high, so the grid came out technically functional, but I wanted something sturdier that didn’t look like garbage with all the strands going everywhere.

After simply lowering the grid down to the appropriate position, these drawers printed without issue. I also printed some bins to go with them, with labels.


Finally, I had all six drawers completed.

I also printed out a tray that’s designed to affix to the top of a wall-mounted bin. There wasn’t enough friction to hold this thing in place, so I ended up sticking a little bit of poster tack to it. It turned out to be just the right thing. It can still be popped off and removed, but now it’s secure enough that I would only be able to do it intentionally.

For mounting the whole thing to the wall, I used weight-bearing snaps and some mid threads. I also had a couple of brackets that would support the bins from underneath.

Each of these mid threads proved to have a good bit of friction, to the point where I couldn’t get the bins to push down onto them securely; they’d just hover halfway-on, halfway-off, unable to go any further. The simple fix was to remove some of them, so I took out the middle row. Even then, it was still too much friction, so I decided to hit the rear connectors with the same lubricant as before.

This got the job done. From there, I was able to secure the bins to the board.

I wasn’t too sure about these brackets I got though. They were supposed to be 3x3, but I misunderstood what 3 meant in this case. The drawers are a 4 in one measurement, but an 8 in another. You’ll see that there are 8 ‘wide spots’ on these rail inserts on the bottom of the bin, and that the bracket is seated in the third of them (thus 3x3).

While the bins looked fine for now, I really wanted these brackets to connect on the front half so the whole thing is less likely to sag. I think it’s a torque thing. So I decided to try a different bracket size, 5x3. This I felt much better about.

Finally, I wanted some labels for my drawers. Multiboard has blank labels as a free option, or you can pay to use the label generator. I decided to try the blank label and found the dimensions weren’t quite right; they were a little too wide so they flexed out when slotted in, and they were thin so they also rocked front to back.
So I decided to do some more modeling. First, I used an online tool to generate STL files of 3D text.

Then, I slightly modified the dimensions of the free label; I made it one layer thicker, and decreased the width by 1mm. From there, I sized and aligned the text, merged it with the label model, and recolored it white in the slicer.

And with that, the drawers were ready. These labels fit perfectly.

Overall, I’m very pleased with how these drawers turned out.
There were still a few things I wasn’t able to fit into them: things like rubber feet, printer maintenance tools, magnets, and sandpaper. These are generally more crafting oriented, so they’ll probably go into one of the larger Sterilite drawer sets once I organize those.
Next up: arc lighting using an LED strip and some PETG.
from
💚
Our Father Who art in heaven Hallowed be Thy name Thy Kingdom come Thy will be done on Earth as it is in heaven Give us this day our daily Bread And forgive us our trespasses As we forgive those who trespass against us And lead us not into temptation But deliver us from evil
Amen
Jesus is Lord! Come Lord Jesus!
Come Lord Jesus! Christ is Lord!
from
💚
🇺🇸
In Christ is The Democrat
For the forgettance Of no-one near and his We were ready for Washington And let’s play at ten There are folds by the window And at two we walked in And prayed for peace, In Christ The reliever of women, The Earth Arts Will cheer every Sunday So that stars of abandonment Will never show It’s in the New Testament To Love One Another As Jesus did And taught And relieved by So that Democrats eternal Have absconded to time To wait for the getting ready For yesteryear When we prepared the way of the Lord And in the future, When He comes Christ’s return May no-one falter Or blink an eye Or tarry Or abscond So absolute, His power We voted for need Of our neighbour, In Him God Bless The Lord Our brethren And our people who live here To be in solemn repose To Heaven with breath To be kneaded in church To save time for our elderly To lend hope to all chasms To bless the reunion Of our peace And our home Our country Built eternal From all directions And done into no fear For eternal peace And our testament of time Is this