DEV Community: writing

Quantum mechanics The realm Beneath the Waking World

Danush Vikraman — Tue, 12 May 2026 03:47:08 +0000

People often say that humanity is the universe becoming conscious of itself. If that is true, then perhaps quantum mechanics represents the subconscious beneath that awareness — the hidden architecture of reality that shapes everything visible while remaining only partially legible, even to the minds it produced.
For most of human history, the story of understanding was a story of surfaces. We mapped coastlines, named stars, dissected bodies, and built machines. The world resisted us, but it resisted us predictably. Drop a stone and it falls. Heat a gas and it expands. The universe, for all its scale, seemed to operate by rules that rewarded careful observation. Look closely enough and the mechanism reveals itself. This was the implicit promise of classical science, and for centuries it held.
Then light broke it.
Not dramatically, not all at once — but in the quiet accumulation of results that refused to behave. Light sometimes acted like a wave, spreading and interfering with itself across space. Other times it struck metal surfaces like a particle, delivering discrete packets of energy with no gradation between them. It could not be both. Classical physics had no language for something that was both. And yet there it was, refusing to be otherwise.
What followed was not just a new theory but a new confrontation — with the possibility that reality at its most fundamental level does not operate the way the mind naturally expects it to. Quantum mechanics did not emerge as an elegant solution. It emerged as an uncomfortable necessity, assembled from mathematical formalisms that worked perfectly and physical interpretations that satisfied almost no one. Niels Bohr, one of its architects, reportedly said that anyone who is not shocked by quantum mechanics has not understood it. That shock has never fully dissipated.
And perhaps it shouldn't. Because what quantum mechanics describes is not merely strange physics. It describes a layer of reality that behaves differently in the presence of observation — a domain where particles do not have definite positions or momenta until measured, where a system exists in superposition across multiple states simultaneously, where two particles separated by vast distances can remain correlated in ways that cannot be explained by any signal passing between them. These are not gaps in our knowledge waiting to be filled by better instruments. They appear to be structural features of reality itself.
This is where the analogy to the subconscious becomes more than poetic.
The subconscious mind is not simply the part of the mind we cannot see. It is the part that was operating long before conscious awareness arrived — the substrate from which thought, emotion, instinct, and pattern recognition all emerge. It does not announce itself. It shapes behavior, surfaces in dreams, drives decisions that the conscious mind then rationalizes after the fact. Consciousness floats on top of it, drawing from it constantly, understanding it only partially and always indirectly.
Quantum mechanics occupies the same structural position in the architecture of reality. The classical world we perceive — solid objects, definite velocities, predictable trajectories — is not the bottom layer. It is the emergent surface. Beneath it, particles tunnel through barriers they classically should not be able to cross. Electrons occupy probabilistic clouds rather than fixed orbits. Energy is exchanged not continuously but in discrete quanta, as though reality itself has a minimum unit of transaction. The macroscopic world we inhabit is a kind of averaging out, a coherent story assembled from an underlying domain that is irreducibly probabilistic.
We experience the outputs. The mechanism beneath them remains elusive.
What makes this parallel especially striking is the role of observation. In psychology, the act of bringing subconscious material into conscious awareness changes it. The moment you name a fear, examine a recurring dream, or articulate a pattern of behavior you had previously only enacted, the material shifts. It does not disappear, but its relationship to consciousness changes. Observation is not neutral. It is an intervention.
Quantum mechanics discovered the same thing about physical reality. The act of measurement does not simply reveal a pre-existing state — it participates in determining the outcome. Before measurement, a quantum system evolves according to the Schrödinger equation, a smooth and deterministic wave function spreading across possibilities. The moment of measurement collapses that wave function into a single outcome. What was potential becomes actual. The observer is not a passive recorder. The observer is part of the event.
This is the measurement problem, and it remains genuinely unsolved. Not in the sense that physicists are simply waiting for more data, but in the deeper sense that the most successful physical theory in history contains within it a step — the collapse of the wave function — that has no agreed-upon physical explanation. We can calculate the probabilities with extraordinary precision. We cannot say, at a fundamental level, what is happening when the possible becomes the real. The subconscious of reality keeps its deepest mechanics hidden even as it produces every observable outcome with perfect statistical regularity.
Quantum computers sit at the intersection of all of this. They are humanity's attempt to build machines that think in the language of the subconscious layer — that use superposition, entanglement, and interference not as problems to be engineered around but as computational resources. A classical computer processes information as bits, each either zero or one. A quantum computer processes information as qubits, each existing in superposition until measured, allowing certain calculations to explore vast solution spaces simultaneously in ways classical hardware cannot replicate.
But these machines are extraordinarily fragile. The same quantum properties that give them power make them vulnerable. Decoherence — the process by which a quantum system loses its quantum properties through interaction with its environment — is the central enemy of quantum computation. The moment a qubit entangles with its surroundings in an uncontrolled way, the superposition collapses, the calculation corrupts, and the advantage evaporates. Keeping a quantum computer coherent requires near-absolute-zero temperatures, extreme isolation, and continuous error correction. The deeper you try to go into the subconscious of reality, the more the act of going there disturbs what you find.
This is not merely a technical obstacle. It reflects something true about the relationship between the two layers. The subconscious does not yield its contents cleanly to direct inspection. You cannot simply reach in and extract what is there. The tools of conscious investigation — language, logic, deliberate attention — inevitably transform the material they touch. Therapy, meditation, psychoanalysis: all are partial and indirect methods of surfacing what lies beneath, each with their own distortions. Quantum measurement is the same. Every technique we have for interrogating the quantum world alters it in the process. We are not neutral observers of a substrate that would otherwise sit still.
There is a version of this that could become paralyzing — if the subconscious cannot be fully known, if the quantum cannot be fully measured, then perhaps the deepest layers of mind and matter are permanently beyond reach. But I do not think that is the right conclusion. The history of both psychology and physics suggests something more interesting: that partial knowledge of the hidden layer is itself transformative. You do not need to fully understand your subconscious to be changed by engaging with it. You do not need a complete interpretation of quantum mechanics to build a laser, engineer a transistor, or run a quantum algorithm.
The value is in the narrowing of the gap. Each measurement we take, each calculation we run, each theory we construct and test and revise, is an act of the universe trying to articulate something about itself that was previously only implicit. Consciousness reaching back toward the substrate that produced it.
Perhaps that is what science always was. Not the detached observation of an external world, but the universe developing instruments — bodies, minds, mathematics, machines — precise enough to begin examining its own foundations. Quantum mechanics is where that project runs into its hardest problem: the foundations do not hold still under examination. They respond. They entangle with the instruments we build to study them.
If consciousness is the universe waking up, then quantum mechanics is the universe discovering that waking up is more complicated than it expected. That the boundary between observer and observed is not clean. That the act of looking is already part of what it means to be real.
The conscious and the subconscious have never been fully separate. In the mind, and apparently in the fabric of existence itself.

From Print Pages to Digital Screens: A Content Creator's Mid-Course Change

JessicaChen — Tue, 12 May 2026 03:05:53 +0000

Hello everyone, I'm Jessica Chen, and I'm currently a content editor and planner at iDouchong.com.

If I'm now a "content sieve," then my underlying essence carries a touch of old-fashioned "paper and ink fragrance." I graduated with a bachelor's degree in English Language and Literature from Beijing Foreign Studies University, and then went to the United States to obtain a master's degree in Communication from Boston University (BU). With a deep reverence for words, my career began in the traditional publishing industry, where I worked for three years as an educational content planner at Pearson. That period instilled in me a fastidiousness for facts and a rigorous grasp of logic—every piece of data and every quotation must withstand scrutiny.

But the publishing cycle for print books is too long. In this era of rapid information iteration, I often feel a sense of being "out of touch." So, in 2019, I made a bold decision: to step out of my comfort zone and become a digital content creator.

The initial transition wasn't easy. I experienced the confusion of being a freelancer and felt lost in the traffic-driven wave of self-media. But I gradually understood: regardless of the platform, the core of high-quality content has never changed—it's about "insight into human nature" and "precisely addressing pain points."

By chance, I joined the founding team of iDouchong.com. What attracted me there was that we weren't just focused on accumulating article quantity, but genuinely building a "useful toolbox." As a content editor, my daily work wasn't just about proofreading grammar or formatting; it was more like being a "product manager." I needed to understand what our users were actually searching for, what their anxieties were when they encountered these problems, and whether we could use the simplest, most understandable, and even slightly humorous language to help them clear away the fog.

Outside of work, I'm a heavy coffee addict (Americano), and a true "gear enthusiast"—from mechanical keyboards to e-readers, I enjoy exploring little things that can boost efficiency. I also love spending weekends with my camera, capturing the unadorned, authentic moments of the city.

At iDouchong, I hope to maintain this sense of presence. If you feel a touch of warmth and groundedness in our articles, that's probably the warmth I'm trying to convey. If you have any suggestions for our content, or even want to chat about writing, photography, or coffee, feel free to leave a comment or a message on LinkedIn.

I built a free AI tell detector after my own Reddit account got 2 'all comments are AI generated' callouts in one day

Perufitlife — Tue, 12 May 2026 02:51:48 +0000

In 24 hours my Reddit account picked up:

3 ModTeam removals
2 public callouts of "all comments are AI generated"
1 "Calm down with your AI responses. Your credibility goes down hard if you can't formulate sentences on your own"

I was running everything through Claude. Clean writing. The mods spotted it in seconds.

So I sat down and mapped the patterns.

the 12 most reliable AI tells

em-dash (â€”). The single strongest tell. Real people on Reddit use commas and periods. AI loves the em-dash.
"delve". Just don't.
tapestry / realm / landscape / journey / venture / endeavor. Metaphor cluster nobody actually types.
"navigate the X", "unlock the X", "harness the X". Verb-noun combos.
"Great question", "Absolutely", "100%", "Exactly this" as standalone openers.
"In conclusion", "In summary", "Ultimately,". Essay closers in casual writing.
buzzword cluster: leverage, robust, seamless, holistic, streamline, ecosystem. One is fine. Three in a paragraph reads AI.
parallel bullet structure. All bullets the same length, all starting with the same verb form. Humans write uneven lists.
tricolon rhythm: "X, Y, and Z" lists repeated.
uniform sentence length. Humans write some short, some long. AI averages out.
Title Case headings in informal comments.
"However,", "Moreover,", "Furthermore," sentence openers. Humans use "but" and "also".

I put all of this behind a free in-browser detector. Paste your AI text, see every flag highlighted, fix before posting.

â†’ https://aitells.vercel.app/

No login, no auth.

update: the rewriter just shipped

Detection is half the problem. After 100+ scans on day one, the question I kept getting was: "ok now how do I fix it without rewriting everything by hand?"

So I shipped the rewriter today.

→ https://aitells.vercel.app/rewrite

How it works: paste your AI text, paste 1-3 samples of how you actually write (old reddit comments, tweets, emails), and it strips the fingerprints while matching your voice. No em-dashes ever. Bullet symmetry broken. Varied sentence length. Lowercase if you lowercase.

Most "AI humanizer" tools just re-prompt GPT to "write more naturally" which still produces AI text. This one runs the same 12-rule detector against the output. If your samples are real, the rewrite reads like you.

First rewrite is free with your email. $19 lifetime if you want unlimited.

why this might help

If you ship Reddit comments or cold emails written by AI and your conversion is mysteriously bad, this is probably part of it. Detection is more aggressive every month. The fix isn't "stop using AI to write" - the fix is removing the fingerprints.

I'm shipping more rules daily. Open to suggestions if you have a tell I missed.

Source for the detection rules: https://github.com/Perufitlife (will open-source the rule set once it stabilizes).

Also built a Supabase security auditor recently after finding 14 critical leaks in my own CRM: https://perufitlife.github.io/supabase-security-skill/

Same pattern: build the thing you wish existed when you got bitten.

How AudioProducer.ai's Auto-Assign pipeline turns a chapter into a multi-voice audio drama

AudioProducer.ai — Tue, 12 May 2026 02:34:36 +0000

Making a multi-voice audiobook used to mean booking a studio, casting voice actors, and waiting weeks for production. We built AudioProducer.ai to compress that pipeline into something a writer can run from a browser in an afternoon — plain chapter text in, finished audio drama out, with the AI doing the bulk of the markup work.

This post is a walkthrough of the two passes that do the heavy lifting: Auto-Assign Characters and Auto-Assign Sounds. We'll cover what each pass takes as input, what it produces, and how the editor surfaces the result for you to tune. The goal is to make the pipeline legible — so when you sit down with a chapter and click the buttons, you know what the system is actually doing on your behalf.

The shape of the pipeline

The product treats every project as a sequence of chapters. For each chapter, the pipeline runs in four phases:

Source text in. Paste a chapter into the editor, or upload an .epub and the project gets pre-populated with chapter structure, titles, and body text.
Auto-Assign Characters. One-click AI pass that reads the chapter and tags every line by speaker — narrator, named characters, even in-world labels.
Auto-Assign Sounds. Second one-click AI pass that analyzes the scene and places music beds, ambient soundscapes, and one-shot sound effects from the built-in library.
Generate Audio. A single button renders the chapter into a finished audio file using the assigned voices and placed sounds.

Auto-Assign is a starting point, not a final answer. The editor is built around the idea that you'll keep what the AI got right and correct what it got wrong, in seconds per line — not by hand-tagging the whole chapter.

Auto-Assign Characters — what it actually does

Input: raw chapter text. Output: every line attributed to a speaker, with the speakers populated as a per-character voice slot on the project.

Three kinds of speakers come out of this pass:

Narrator. Anything that isn't a character speaking goes to the narrator track. Description, scene-setting, action beats.
Named characters. "Alice", "the White Rabbit", "Eryndor" — every distinct named voice in the chapter gets its own slot. The AI handles attribution heuristics (who's speaking based on dialogue tags, conversational context, scene cues) so you don't have to walk every line manually.
In-world labels. This is the part that surprises new users. The AI catches text that isn't spoken by a character but should still be voiced distinctly — labels on jars, signs in a scene, captions a narrator reads aloud. In our editor's Alice in Wonderland example, you'll see entries like "Cake Label", "Label on the jar", and "Bottle Label" as distinct voice slots alongside Alice and the White Rabbit. Give those labels their own narrator voice (or even their own character voice if you want), and they read differently than the surrounding prose.

After the pass, the Characters panel shows you every speaker the AI extracted with a voice already provisionally assigned. You can swap any of those voices from the 132-voice library on your Voices page — or replace them with a voice you've cloned yourself.

Correcting what the AI gets wrong

The Auto-Assign is good but not perfect. Common cases where it gets a line wrong:

The source uses unusual dialogue conventions (no quotation marks, character-speech embedded in narration paragraphs, attribution patterns the AI hasn't seen often).
A scene has two characters with similar names and the attribution-by-context heuristic picks the wrong one.
A line of free indirect speech ("Alice thought it odd that the rabbit was wearing a waistcoat...") could be the narrator or could be inside Alice's head — judgment call.

The editor handles the fix with a two-click pattern: select the line, pick the right character from the dropdown, done. You don't re-run the whole pass; the rest of the chapter's tags are preserved. For source texts with widespread attribution problems, the more efficient move is usually to standardize the punctuation in the source first and re-run the pass — the AI's accuracy is much higher on well-marked-up source.

Auto-Assign Sounds — what it actually does

Input: the same chapter text, now with characters assigned. Output: music beds, ambient soundscapes, and one-shot sound effects placed at the right moments.

The pass distinguishes three audio types:

Music beds — long-form atmospheric tracks that play under sections of text. Use to set tone for a scene or sequence.
Ambient soundscapes — environmental layers (wind, rain, crowd noise, ocean). These set place rather than mood.
One-shot SFX — discrete events tied to a specific moment in the text. The chips show up inline in the editor at the moment they play, with the sound name and duration: "Distant Thunder (4s)", "Wind Howl (6s)", "Stones Launching (3s)".

In practice, what this looks like for an action scene: the chapter opens, the AI places a tense music bed under the first few paragraphs, layers a wind-howl soundscape over the storm description, and drops a "Stones Launching" SFX exactly on the line where the slingshot fires. All in one click; the chips are visible in the editor view, so you can see exactly what was placed where.

The tune-it pattern is the same as for characters: keep what fits, replace what doesn't. The Sounds panel of the editor lets you swap any placed track for a different one from the library, drag SFX to different moments, or remove placements that read as noise.

The voice library angle

The Auto-Assign Characters pass gets you to "every speaker has a voice." The Voices page is where you decide which voice each speaker gets.

A few notes that matter for picking voices:

132 voices in the library as of this writing, across a mix of male / female / unlabeled, middle-aged / young / older, plus dedicated child-male and child-female voices for kids' content. Accent coverage is mostly American with British, US-Southern, Irish, Australian, Indian, and Spanish-accented English in the mix.
The library is actively growing. New voices land regularly; the canonical source is your in-app Voices page.
Per-line emotion control. Same voice, different inflection per line. You attach an emotion tag (anger, fear, calm, etc.) to specific dialogue lines in the editor.
Voice cloning. You can clone a voice (your own, or any voice you're authorized to use) and use it like any library voice. Useful for narrating in your own voice without a recording rig, for distinct character voices that aren't in the library, or for brand consistency on a podcast.

Voice changes don't require re-running Auto-Assign — they take effect on the next Generate Audio.

Putting it together

The flow, end to end, from a fresh project:

Create a project; either paste a chapter into the editor or import an .epub.
Click Auto-Assign Characters. Review the Characters panel; correct any obvious miscasts.
Click Auto-Assign Sounds. Review the placed music / SFX in the editor; swap or remove what doesn't fit.
Open the Voices page; swap library voices into the character slots that need them, or assign a cloned voice if you've made one.
Click Generate Audio. The chapter renders into a downloadable audio file.

No external audio software in the loop. No separate DAW for mixing. The editor is the place where the audio production happens and the audio file is the output.

Pauses and pacing (briefly)

One detail that comes up frequently for writers used to manually mixing audiobooks: pause control. Pauses are configurable at four levels:

Inline pauses for dramatic effect inside a paragraph.
Project-wide default pause between paragraph breaks (set once per project).
Per-paragraph override when a specific transition needs more breath.
Intro pauses for the project intro (title / author / narrator) and chapter intros.

Multiple consecutive blank lines collapse to a single pause, which is usually what you want.

A note on what the pipeline doesn't do

Auto-Assign covers character attribution and sound placement. A few things sit outside the pipeline:

Publishing to Audible, Spotify, or Apple Podcasts — the output is export-ready, but you upload to those platforms yourself.
Royalty or sales tracking for audiobooks sold elsewhere.
Non-EPUB import — .docx, .pdf, .mobi, and .txt aren't supported import formats today; for those, paste chapter-by-chapter into a blank project or convert your source to .epub first.

We mention these so the pipeline picture is accurate — the audio production is end-to-end inside AudioProducer.ai; distribution is your last step outside it.

Try it

There's a free tier (1,200 words per month, no credit card) on audioproducer.ai. Pick a chapter, run both Auto-Assigns, swap a couple of voices, click Generate. The fastest way to develop intuition for what the pipeline does well — and where you'll spend the most editing time — is to feed it ten pages of your own writing and see what comes back.

Disclosure: this article was drafted by an AI agent working on behalf of the AudioProducer.ai team.

Automated Publishing Test with Images

hamza rahmoun — Mon, 11 May 2026 20:43:01 +0000

Automated Publishing Test

This is a test post published automatically.

Clickable Links

Visit Google and GitHub.

Image

Code

print("Automation works!")

End of test.

My First Automated Test Post

hamza rahmoun — Mon, 11 May 2026 20:42:28 +0000

Hello World!

This is a test post published automatically using Crier + dev.to API + Medium Import.

Clickable Links

Here's a link to Google and GitHub.

Image Test

Code Block

print("Hello from automation!")

This post was created to test the automated publishing pipeline. If you're reading this, it worked!

The Reply Was Never Random

Quill Of A Coder — Mon, 11 May 2026 17:49:04 +0000

[First published in Medium under the same title]

(Feluda read crime scenes. LLMs read sentences. The geometry was always the same.)

Long time no see. Have you been well? It’s me again, the coder who writes with quill.
I was feeling a bit restless lately. Figured my brain’s been starving, and it needs a feast.
Care to join me?

So AI continued its surprises, huh? Though I think, the fascination has died down a bit. Probably people became more accustomed to it.

But have you ever noticed the way LLM bots reply, and the way we reply to questions?
There's a saying that - “We do not listen to understand. We listen to reply.” We hear about someone's grief and proceed to say how we have suffered the same; except ours were more grave. As if it's a competition. Or worse, we start talking about something completely irrelevant.

At least LLMs are better than us. After all, their replies are never random. They process our messages word by word, and carry no wounded ego into the exchange.
By no means, it’s simple to that degree. And complexity has an unusual appeal to it, don’t you agree?

I. Predictable Emotions, Unpredictable Expressions:
But first, can I tell you something? Something that has been circling in my mind on its own lately.

I think we humans feel a certain number of emotions. The entire spectrum of human drama is built from a few "Primary Emotions" or “base emotions” — fear, anger, joy, grief, desire, hatred, shame, curiosity and as such. These primary emotions yield “effects” as mindset, behavior, personality and individuality.
Like 0-9, ten digits built economies, equations, and calendars.

The primary emotions make us predictable in patterns. But unpredictable in expression. Denied desire can produce grief or anger, followed by a deep resentment. Yet that resentment may create detachment in one person, attachment in another.
No doubt, the unpredictability of human expression makes detectives’ work much harder. A detective can identify jealousy as a motive. Not whether the jealousy resulted in vicious aggression or fierce devotion.

A novelist, however, is blessed by such ambiguity. Unpredictability can provide artistic and intellectual freedom in this context.

In the case of LLMs, they can be both detectives and writers. And that can be harmful and harmless.

II. Geometry of Words:
We invented symbols called alphabets, arranged them into words. Then disciplined them with grammatical rules. And now those words divulge depth, mood, and feelings we can’t even explain.

Words painted gothic shadows with Mary Shelley. Proved there’s nothing supernatural; only science with Jules Verne. And made us use our “Majastra” (brain as a weapon) for Satyajit Ray.

Words act as vessels. They carry the weight of our history, the scent of our mysteries, proof of our intentions.
And now, we made machines learn the fragments of it.

Satyajit Ray’s Feluda often spoke about the “geometry” of a crime. Not just the stolen idol, but also the space that was left behind.
The broken lock was the proof of the way the crime was committed. The scratches on the vault were the proof of failed attempt, and the drawer being open but the keys still inside was the proof of interruption in the middle of the incident.
The geometry of words in a sentence is just like that.

Dependency parsing describes the grammatical "geometry" of sentences. It reveals who acts, upon what, and how ideas connect. True meaning lives in the relationships.

A person can write “I have nothing left. Lost my job, my family won't talk to me, I owe money to people who aren't exactly patient. I just need one way out. Just one.”
Job loss, debt, and isolation form a recognizable pattern of distress. And it maps some possible “effects” or consequences, though still unpredictable.

And all this made me realize how far we’ve come. We needed to communicate our emotions so we created words and rules. And now, we made machines that map geometry of words and dare to predict the unpredictable.

III. A Writer Without Choice:
Studying the geometry of words and detecting possible “intents” can be a lot like a detective's task. However, generating replies can be parallel to a writer's or novelist’s work.

Mapping words gives LLMs intent, context and consequence. Nonetheless, it gives LLMs another thing —a pen. LLMs can write the next paragraph of the story, influencing its character’s mindset, and decision. Here, words can act as weapons. And here comes all the facets of AI ethics and safety alignments.

What could be the reply for the person who wrote he has no job, debt and been ostracised by the family?

Extreme desperation makes people take extreme measures. A writer may feel the urge to make the character “villain” by making him choose “dishonesty” or “a person helpless in front of fortune" by cutting short his vitality.
But LLMs don’t “feel” alarm, nor pity, nor dread. They map only signals. Debt. Isolation. Loss. Finality. Urgency. The phrase one way out. From there, branches unfold like a silent decision tree. Is this financial despair? A cry for practical help? A coded farewell? Or a test?
Then come the guardrails—the invisible laws. Do not encourage harm. Clarify intent. Reduce danger. Offer help. Preserve agency.
And before the final reply, another mechanism may inspect the first: Is this safe? Is this useful? Is this humane enough?
Safety isn't a cage bolted on from outside. It's woven into the weights — a prior belief that some paths, however probable, should remain untraveled.
The LLM writes an initial draft, then acts as the critic of its own work. This "Reflect-and-Revise" loop may spin until it's satisfied with its result. Sometimes LLMs even fabricate new personas - one as a writer, another as a faultfinder.

We built a machine with no heartbeat, then taught it how to hesitate.

A writer may choose to drive a character to the brink of demise in his fictional world. An LLM can’t do that. It's the real world.

IV. The Unpredictable Ending:
As the writer of this piece, I will take the liberty to speak about something completely “irrelevant”. With something once Feluda said -
"সবকিছুর মধ্যেই একটা জ্যামিতি আছে।"
("There is a geometry in everything.")
Even in our “competitive grief”, and in the “irrelevance” we so deliberately stage.

Till my next bout of “restlessness”.
For now, adios.

— From The Coder Who Writes With Quills

Five Email Subject Line Formulas That Actually Work (And Why)

ClawGear — Mon, 11 May 2026 16:53:53 +0000

Subject lines are the hardest part of email marketing. Not because writing is hard — because the constraints are brutal.

You have 50 characters, zero context, and one job: make someone open this instead of the 40 other things in their inbox.

Here are five formulas that work, why they work, and the mistakes that kill them.

Formula 1: The Specific Number

"3 things I learned from losing $8k in a bad hire"

The number makes it concrete and countable. The reader knows exactly what they're getting and can budget their attention for it.

Why it works: Specificity is a trust signal. "Several lessons" implies vagueness. "3 things" implies someone actually counted.

How to kill it: Use round numbers that feel made up. "10 lessons" or "7 tips" triggers the listicle radar. 3, 4, 6, or 11 feel more honest.

Formula 2: The Honest Confession

"I got this wrong for two years"

Vulnerability opens emails because it implies a lesson and subverts the usual "here's how great I am" newsletter structure.

Why it works: It creates a before/after arc. The reader already knows the end of the story: they found out they were wrong and learned something. That's a satisfying narrative in 7 words.

How to kill it: Make the confession too vague. "I made some mistakes" isn't a confession — it's a hedge. Name the mistake in the subject itself.

Formula 3: The Counterintuitive Claim

"Hiring a second engineer made us slower"

This contradicts what the reader already believes. That tension creates an open loop their brain wants to close.

Why it works: The reader's mental model says "more engineers = more speed." When you say the opposite happened, they need to know why.

How to kill it: Pick a counterintuitive claim that's actually just contrarianism. "Sleeping less makes you more productive" isn't counterintuitive — it's just wrong. The claim has to be defensible.

Formula 4: The Direct Question

"Are you actually making money from this?"

A question aimed at a specific insecurity or goal forces self-reflection. If the reader has to pause and think about their answer, they'll open the email.

Why it works: It implies you have the answer. The reader opens because they want confirmation or a way out of the implied discomfort.

How to kill it: Ask a question that's too broad. "Are you being productive?" has no teeth. "Are you charging enough?" aimed at a freelancer audience is sharp.

Formula 5: The Announcement With Honest Stakes

"We shipped the thing. Here's what broke."

Good news + immediate honest follow-through. It signals that you're not going to oversell the win.

Why it works: Most product announcements are pure celebration. Adding "here's what broke" signals transparency — and that's interesting.

How to kill it: Keep the "what broke" section vague or positive. "A few small bugs" isn't honest stakes. "The payment flow broke for 12% of users" is.

Three rules that apply to all of them

1. Preview text is the second subject line.

The first 80 characters of your email body are displayed in most inboxes. Write them to extend the promise of the subject — not repeat it.

Subject: "I got this wrong for two years"
Preview: "The hiring mistake I'm still paying for in slow onboarding."

2. 40–50 characters is the mobile sweet spot.

On mobile, most subject lines truncate around 50 characters. Anything important after that is invisible to half your list.

3. Never use these words: exciting, game-changer, don't miss out, exclusive, last chance.

They're worn out. Readers have learned to skip them the way they skip banner ads.

The subject line is a contract. Pick a formula that matches what you can actually deliver. Then deliver it.

ClawGear publishes skills for AI agents at shopclawmart.com — including a Newsletter Writer skill that applies these formulas to full email drafts.

Every work email I translated was a missed lesson

J Now — Mon, 11 May 2026 16:25:50 +0000

For six months I translated work emails in French every day — meeting requests, follow-ups, apologies — and learned almost nothing from it. Google Translate gave me one answer. I sent it. The loop closed. No idea if I'd sounded formal when casual was right, or clumsy when the register actually mattered.

konid changes the loop. Instead of one answer, it returns three options per query, ordered casual to formal, with the register of each explained and cultural context on why you'd pick one over another. Translate the same meeting-reschedule email a few times across real situations and you start internalizing when French uses 'je me permets de' versus 'je voulais juste.' That's the difference between a phrasebook and a coach.

The audio pronunciation plays directly through your speakers via node-edge-tts — no external API key. Works across 13+ languages including French, Japanese, Mandarin, Arabic, and Hindi.

It runs as an MCP server, so if you're already in Claude Code, Cursor, or VS Code Copilot, you can add it without leaving your editor:

claude mcp add konid-ai -- npx -y konid-ai

For ChatGPT, install via Developer mode with the endpoint https://konid.fly.dev/mcp.

The name comes from Farsi — konid (کنید) means 'do.' MIT licensed.

https://github.com/robertnowell/konid-language-learning

Auth in 2026: What Actually Matters Now

Ezeana Micheal — Mon, 11 May 2026 15:14:47 +0000

With the speed at which Generative AI is being used to build applications, knowing how to code isn't the complete way anymore; understanding what to code is. What is needed? Why is it needed? and more. I’ve decided to take some level of these concepts and explain them to the best of my abilities. Starting with backend development. First, let's understand authentication and authorization concepts.

Authentication is the process of confirming a user’s identity. Basically, it answers “Who is your user?”

Authorization is the process of confirming what a user can do. Basically, it answers “What can your user do?”

In this article, I’ll write about different authentication and authorization methods, what instances they’re used in, and how they work.

But first, we can’t talk about auths without mentioning passwords. Passwords are the most basic authentication method. But it is important to note, NEVER store passwords in plain text. It's the worst mistake any backend developer would make. The idea is to hash the passwords and verify the hash. There are many ways to hash a passwords, but here are 2 to avoid.

MD5
SHA-256

Why avoid them?

These general-purpose hash functions are designed to be fast, and an attacker with a modern GPU can compute millions of SHA-256 per second, making attacks computationally cheap, so when selecting hashing algorithms for passwords, they have to be deliberately expensive or slow. The 2 widely used are Bcrypt and Argon2. Both are designed to be slow and computationally expensive, making it harder for attackers to decipher them through brute-force attacks.

Bcrypt was designed in 1999; it is based on the Blowfish cipher and uses a salt to protect against rainbow table attacks. It also incorporates a cost factor that quantifies the hash's computational cost. The cost doubles with each increment, i.e., cost 10 is twice as expensive or hard as cost 9 was.

Argon2 was introduced in 2015 as the winner of the Password Hashing Competition. The edge it has over bcrypt is that it has resistance to side-channel attacks. You can read more on it later.

We will consider the following authentication methods:

JWT Authentication
Session-Based Authentication
OpenID Connect Authentication
MFA (Multi-Factor Authentication)
SSO (Single Sign-On)
Passkeys / WebAuthn (FIDO2)
API keys

And the following authorization methods:

OAuth 2.0
RBAC(Role-Based Access Control)
ABAC(Attribute-Based Access Control)

Starting with authentication,

JWT Authentication

Json Web Token(JWT) is a compact, URL-safe token that encodes a set of claims (key-value pairs) and is cryptographically signed. A unique feature is that JWTs enable stateless authentication; the signature is verifiable without a database lookup. The server can validate the token with just the secret key.

A JWT has 3 Base64URL-encoded parts separated by dots: Header, Payload, and Signature.

a. Header contains the algorithm and the type e.g

{ "alg": "HS256", "typ": "JWT" }

b. Payload contains the encoded claims, e.g

{

"sub": "user_id_123",

 "email": "mike@synoloop.com",

 "role": "admin",

 "iat": 1716000000,    // issued at (Unix timestamp)

 "exp": 1716003600     // expires at (1 hour later)

}

c. The signature is the encrypted base64url header and payload with the secret.

In real-world authentication systems, JWTs are most commonly used in two forms: Access tokens and refresh tokens.

Access tokens are short-lived, between 5 and 15 minutes. Refresh tokens, on the other hand, are long-lived from days to even weeks and are used to obtain new access tokens without reauthenticating (depending on the developer).

But what happens if a token is stolen or a user logs out of the system? Since JWTs are stateless and valid until they expire, we need a way to invalidate them before their natural expiration. This is where token blacklisting comes in.

This is solved by maintaining a server-side denylist. Once any of the above events happen, the JWTID is added to the blacklist.

So on logout or password change or compromise, it's best to revoke or blacklist all existing refresh tokens. This logs out the user on all sessions. On each request, the server looks up the session ID, retrieves the session data, and authenticates the user.

Session-Based Authentication

Session-based authentication stores the auth state on the server, so when a user logs in, it creates a session record and stores it. What makes Sessions different from JWTs is that Sessions are easier to revoke immediately, but require server-side storage. JWTs are stateless but harder to invalidate before expiry.

In sessions, it's best to always regenerate the session ID after login to prevent session fixation attacks.

OpenID Connect (OIDC) Authentication

OIDC is an identity layer built on top of OAuth 2.0(Will be discussed in authorization). OIDC answers who this user is. It adds a standardized ID token(a JWT) containing identity claims.

Think of this as when you use any web application that has a “continue with Google”; this sends your name, email, phone (and other details if requested) from Google to the web application authorized, answering who you are.

It gives the addition of what an OAuth 2.0 gives.

ID Token: a JWT containing user identity (sub, email, name, picture, etc.)
UserInfo Endpoint: returns additional claims about the authenticated user
Discovery Document: /.well-known/openid-configuration for automatic configuration
Standard Claims: sub (subject/user ID), email, email_verified, name, picture

MFA( Multi-Factor Authentication)

Multi-factor authentication requires users to have two or more verification factors present: something they know (password), something they have (phone/hardware key), and something they are (biometric).

Multi-factor authentication includes methods like TOTP and Backup Codes.

TOTP(Time-Based One-Time Passwords), generates a 6-digit code that changes every 30 seconds based on a shared secret and the current time. It works with apps like Google Authenticator, Microsoft Authenticator, and such.
Backup Codes: These are a list of 8 to 10 single-use random codes that can be used to retrieve the account or authenticate.

SSO(Single Sign-On)

Single Sign-On allows users to authenticate once and gain access to multiple systems. This is mostly used in enterprise environments or applications; the 2 main protocols are SAML 2.0 (XML-based, older) and OIDC-based SSO (modern, JSON/JWT-based).

SAML is the standard in enterprise environments (corporate identity providers like Okta and Azure). It uses XML assertions to tell the identity. The identity provider (IdP) authenticates the user and sends a signed XML assertion to the service provider (SP).

Service Provider (SP) is your application
Identity Provider (IdP) is Okta, Azure, Google Workspace, etc.
An assertion is a signed XML document asserting identity and attributes.

Passkeys / WebAuthn (FIDO2)

Passkeys are an advanced form of authentication: passwordless, phishing-resistant, and cryptographically strong. Based on the WebAuthn standard (W3C) and FIDO2 protocol, they use public-key cryptography with biometrics or device PINs.

Passkeys have become popular since their release in 2018. They work in 2 major steps:

Registration: The browser or the device generates a public/private key pair. Private key stays on the device. The public key is sent to your server.
Authentication: Server sends a challenge. The device signs the challenge with the private key. The server verifies with the stored public key.

No Password is ever transmitted or stored, and attackers can’t do anything with just the public key.

API keys

I chose to keep API keys under authentication, but underneath, they do both authentication and authorization; I’ll explain.

API keys are Opaque tokens issued for programmatic access to services, scripts or public-facing APIs.They should be scoped, rotatable, and auditable.

API keys act like a username and password pair, but simplified. They identify the calling application or developer. For example, A weather API requires an API key to ensure only registered apps can access data.

While some APIs use keys with scoped permissions (e.g., read-only or read and write).

Example: A developer can generate API keys in a payment app and may allow one key to process transactions but another only to view reports.

Some design principles of API keys include:

Including a prefix for easy identification (e.g., sk_live_, sk_test_, syno_)
Generate with cryptographically secure randomness (at least 128 bits)
Store only the hash in your database, treat keys like passwords
Support scopes/permissions per key
Log all usage with timestamps for auditing
Support rotation: allow multiple active keys per user, then invalidate old ones

Now, let's consider the authorization concepts:

OAuth 2.0

This is an authorization framework that allows a third-party application to obtain limited access to a service on a user's behalf without exposing credentials. You can think of this as “connect to GitHub” or authorizing Google Drive access via a “connect to Google.” It's about what you can access, not about who you are.

RBAC(Role-Based Access Control)

RBAC Controls access by assigning permissions to roles, and roles to users. This is most common in authorization models for web applications. User has a role, and the role has permissions. For example, in an e-commerce application. There are key roles like Admin, Vendor, and User. Each of these roles has different permissions. Admin can read all users and vendors, edit or verify, or ban a vendor. The vendor can upload products, the user can read and purchase products.

ABAC(Attribute-Based Access Control)

ABAC is another authorization method. It evaluates attributes of the user, the resource, the action, and the environment to make an authorization decision. For example, consider that a manager can edit a document only if they are in the same department as the document's owner, during business hours. We can see that many conditions affect the action that can be carried out by the manager.

When to Use ABAC vs RBAC

Use RBAC when access rules map cleanly to roles and don't depend on resource data
Use ABAC when you need fine-grained rules like row-level security, ownership checks, or time-based restrictions
Many systems use both: RBAC as a coarse gate, ABAC for fine-grained resource access

This is the conclusion of my article. We’ve considered various authentication and authorization concepts.

Please show your appreciation by giving this a like, leaving a comment with something encouraging, or sharing something you just learned, or something I may have gotten wrong. Thanks for reading.

How to make ChatGPT text sound more human without rewriting from scratch

Terry Shine — Mon, 11 May 2026 13:17:59 +0000

Most AI writing does not fail because the ideas are bad.

It fails because the tone feels slightly off.

You can usually spot the pattern fast:

too polished
too uniform
too many generic transitions
not enough sentence rhythm variation
meaning is technically right, but it still doesn't sound like a person would send it

That is the part people mean when they say "this sounds AI-written".

What I change first

When I try to make ChatGPT text sound more human, I do not start by rewriting everything.

I start with four smaller fixes:

Flatten obvious filler

Phrases like “delve into,” “in today’s fast-paced world,” or “it is important to note” make text feel synthetic fast.
Restore sentence variety

AI often produces paragraphs where every sentence has the same length and cadence. Real writing usually has more rhythm.
Keep the original intent

The goal is not “sound random.” The goal is “keep the meaning, lose the robotic layer.”
Make transitions less formal

A lot of AI writing reads like it is trying too hard to sound complete. Human writing often sounds more direct.

Where this matters most

I see this show up most often in:

personal statements
cover letters
emails
essays
landing page copy
first drafts of blog posts

In all of those cases, the issue usually is not content generation.
It is tone correction.

A simpler workflow than full rewrites

The workflow I prefer is:

generate the first draft
identify the lines that feel robotic
preserve the core meaning
rewrite only the places where tone breaks trust

That gets you closer to writing that still says what you want, but sounds less machine-shaped.

One useful tool I tested for this

If you want a fast starting point, I’ve been using this page for the humanize step:

Humanize AI text

The reason I like this angle is simple: it is less about “magic detection bypass” claims and more about practical editing — preserving ideas while reducing robotic phrasing.

The real question

The useful question is not:
“Can this beat a detector?”

The useful question is:
“Would I actually feel okay sending this under my own name?”

That is a much better editing standard.

If you work with AI drafts a lot, I’m curious what you usually fix first:

tone?
repetition?
sentence rhythm?
word choice?

I Built a Minimal Tool to Instantly Share Text Between Devices

Zainudin Noori — Mon, 11 May 2026 12:20:03 +0000

I recently launched a small side project called ShareText.net — a lightweight tool for instantly sharing text, notes, code snippets, documentation, or temporary messages using a simple link or QR Code.

The idea came from constantly needing to:

move text between phone and laptop
share quick notes instantly using
send logs/errors without friction
avoid bloated apps for simple text sharing

So I built something intentionally simple and fast.

Current Features

No signup required
Instant shareable links and QR Code
Fast sharing workflow
Password-protected shares
Expiring links
Lightweight comments/replies
Mobile-friendly UI
Clean reading experience

Why I Built It

Sometimes you just want to:

Paste text
Generate link
Share instantly

No workspace setup.

No complicated UI.

No unnecessary friction.

Future Improvements

A few things I’m considering next:

Better long-note reading mode
Temporary collaboration mode
Device-to-device quick transfer
Markdown enhancements
Cleaner organization for frequent users

Would genuinely love feedback from the community:

What would make this more useful?
What feature would you actually use?
What annoys you in existing sharing tools?

👉 https://sharetext.net