--------------------------------------------------------------------------------
title: "AI adoption is not transformation"
description: "Most companies bolt AI onto their org chart. The org chart is the problem."
last_updated: "2026-04-28T00:00:00Z"
source: "https://jafe.cc/writing/your-company-is-middleware"
--------------------------------------------------------------------------------

An AI-adopted company runs AI on top of its existing structure. An AI-native company designed its structure around what AI can do. Most companies think they're becoming the second by doing more of the first.

They're not.

A company adds meeting summaries, a support chatbot, a copilot for the sales team. The spend goes up. The org chart doesn't move.

Here's the thing nobody wants to hear. The org chart exists because information couldn't move on its own. A human had to carry it. A meeting had to exist so five people could hear what the software should have surfaced already. That's it. That's the whole reason.

And a status meeting with an AI notetaker is still a status meeting. You've made the waste faster. You haven't removed it.

## The carrying layer

Think about what a middle manager actually does on a given day. They collect context from reports, compress it into a status update, carry it upward, carry decisions back down. They're a human protocol stack. That's not a dig at middle managers. It's a dig at the systems that made the role necessary.

When every internal surface is queryable, you don't need that layer anymore.

I built an agent for a B2B SaaS support team that does exactly this. Tickets come in, the agent classifies them, pulls context from the knowledge base, resolves L1 issues on its own or routes to the right person with full context attached. Before that, a human read every ticket, searched for answers, typed the response, decided whether to escalate. Fifteen to twenty minutes per ticket. The agent handles the same volume without adding headcount.

The before state: a ticket lands in JSM, a human reads the email, opens Weclapp, searches by the customer's email or number, navigates through several layers of the client page to surface account history, then goes separately to Confluence and Jira to find related docs and similar issues. All of that context lives in separate systems. None of it is in the ticket. The human is the join query.

This is how it looked.

<StepFlowchart height='520px' showProgress={true}>{`
flowchart TD
  A([Ticket in JSM]) --> B[Read email, find customer]
  B --> C{Customer identifiable?}
  C -->|No| D[Reply asking for details]
  D --> A
  C -->|Yes| E[Open Weclapp, search by email or number]
  E --> F{Right customer?}
  F -->|No| E
  F -->|Yes| G[Dig through client page layers]
  G --> H[Pull account history]
  H --> I{Enough context?}
  I -->|No| J[Search Confluence]
  J --> K[Search Jira]
  K --> L{Anything relevant?}
  L -->|No| M[Reply without full context]
  L -->|Yes| N[Piece it together manually]
  I -->|Yes| N
  N --> O([Set SLA, reply or escalate])
`}</StepFlowchart>

Now with the agent, a JS script runs on a cron and does all of that before a human even opens the ticket.

<Flowchart height='1000px'>{`
flowchart TD
  CL{Classify}
  RT[Enrich + route]
  HO[Create opportunity]
  QU[Route to queue]
  CL2([Close ticket])

A([JSM ticket]) --> B{Email in Weclapp?}
B -->|Yes| C[Fetch account data]
B -->|No| D{Domain match?}
D -->|Yes| C
D -->|No| E[Flag: unmatched]

C --> F{Usage drop?}
C --> G{KB match?}
C --> H{Similar issue?}

F -->|None| FA[No churn]
F -->|Risk| FB[Churn risk]
G -->|Strong| GA[Draft reply]
G -->|None| CL
H -->|Yes| HA[Past fix]
H -->|No| CL

FB --> FC[Sync + alert]
FA --> CL
GA --> CL
HA --> CL
E --> CL
FB --> CL

CL -->|Trivial| auto([Auto-deflect])
CL -->|L1| hitl([HITL review])
CL -->|L2| RT
FC --> RT

RT --> TG{Tag}
RT --> SL[Set SLA]
RT --> AG[Assign agent]

TG -->|Sales signal| sa[Sales opportunity]
TG -->|Usage gap| tr[Training needed]
TG -->|Account risk| ac[Account escalation]

sa --> HS{In HubSpot?}
HS -->|No| HC[Create contact]
HS -->|Yes| HO
HC --> HO

SL --> SLA{Tier x package}
SLA -->|Ent Premium| SLB([P1 same-day])
SLA -->|Ent Standard| SLC([P1 24h])
SLA -->|SMB| SLD([P1 48h])

AG --> QU
QU --> RS{Resolved?}
RS -->|Stalled| NU[Nudge agent]
NU --> QU
RS -->|Escalated| SE([Senior support])
RS -->|Yes| LO[Log outcome]

LO --> GB{KB gap?}
GB -->|Yes| KR[Feed to KB]
GB -->|No| CL2
KR --> CL2
`}</Flowchart>

I built another agent for the same company that reduced system configuration from two hours to under ten minutes. The old process was a human reading a spec, clicking through a settings UI, checking the output, fixing mistakes. Now the agent reads the spec and writes the config. A human reviews it. The bottleneck moved from doing the work to checking the work.

And here's what I keep telling people. None of this required a better model. It required writing the process down in a form the agent could actually follow.

## The role nobody's hiring for

Every failed AI deployment I've seen has the same shape. The domain expert knows the process but can't turn it into instructions a machine can run. The engineer can build anything but has no idea what to build. And nobody sits between them.

That's the gap. Someone needs to watch the process as it actually happens — not as someone describes it in a meeting — find the parts that are real judgment and the parts that are just habit, and separate them so agents handle habit and humans handle judgment.

If you're inside a B2B company and your AI projects keep stalling, it's probably because nobody owns this work. Someone needs to be the translator between how your company actually operates and how agents can operate inside it. The tooling is ready. The models are ready. The wiring is the bottleneck.

This is the first post in a series I'm calling The Post-Coordination Company. The next posts get into the practical stuff. How to design processes that agents can actually run. How to pick infrastructure that supports them. What the org looks like when you stop building around information that can finally move on its own.


--------------------------------------------------------------------------------
title: "Two weeks of typing without predictive text"
description: "Discoveries made while typing without predictive text suggestions for two weeks"
last_updated: "2025-09-23T00:00:00Z"
source: "https://jafe.cc/writing/two-weeks-without-predictive-text"
--------------------------------------------------------------------------------

My phone was putting words in my mouth and I didn’t even realize it.

I discovered this while hunting for ways to squeeze more battery life out of my iPhone. Deep in a Reddit thread about iOS optimization, someone casually mentioned that predictive text burns through battery with all its background processing. Minimal impact, they said, but still there.

I was about to dismiss it as another marginal optimization when I paused. When was the last time I'd actually typed a message without those three suggestions hovering above my keyboard? When had I last spelled "adequate" or "synonymously" from memory instead of tapping the first suggestion?

Then it hit me. I'd become completely dependent on a feature I'd never consciously chosen to rely on.

## The experiment

I toggled off predictive text that same day.

The first week was genuinely uncomfortable. I found myself pausing mid-sentence, unsure if I'd spelled words correctly. I second-guessed spellings of words I use frequently.

By week two, something shifted. Words felt more intentional, messages became more thoughtful. Not from extra effort, but from engaging with muscle memory instead of algorithmic suggestions.

## Your brain on autocomplete

What I hadn't considered: Predictive text doesn't just save time. It actively rewrites how you think about language.

When your phone suggests the next three words, you start choosing from its suggestions instead of your vocabulary. Your writing voice becomes a collaboration between you and Apple's language model.

That's the trap. You think you're being more efficient, but you're actually outsourcing the creative act of word choice to software.

## The tap and swipe strategy

Rather than go all-or-nothing, I came up with two approaches:

**Tap-type for control.** No suggestions, no corrections, just deliberate character selection. Perfect for important emails, thoughtful messages, anywhere creativity matters and I want to reflect on how to communicate my thoughts.

**Swipe-type for speed.** Swiping uses autocorrect on iOS, so I swipe for quick replies and casual texts where the algorithm can actually help.

Two input modes for two different needs. Revolutionary? No. Effective? Absolutely.

## What I kept (and why it matters)

I didn't turn my iPhone into a Nokia 3310. Text replacements stayed on. "vg" still expands to "Viele Grüße" (the casual German equivalent to "kind regards"). My email signature still autofills from "sig".

The rationale is simple: Optimize for intention, not just efficiency. I kept the text replacement shortcuts I created while ditching the sentence completion with short-term convenience but long-term cognitive costs.

## The real win

Did it actually improve my battery? Hard to measure, but probably slightly. One less background process constantly analyzing my typing patterns and generating predictions.

But that wasn't the real win. The real win was breaking free from a dependency I didn't know I had.

Your phone should amplify your capabilities, not replace them. When predictive text stops predicting and starts prescribing, it's time to turn it off.

Try it for a week. Your thumbs will complain, but your brain will thank you.


--------------------------------------------------------------------------------
title: "Capture thoughts to Obsidian with Siri Shortcuts"
description: "A simple workflow to quickly capture a thought to Obsidian"
last_updated: "2023-10-10T00:00:00Z"
source: "https://jafe.cc/writing/thought-capture-obsidian-siri-shortcuts"
--------------------------------------------------------------------------------

## Inspiration

In my daily routine, I've found it really helpful to quickly jot down my thoughts. These thoughts might be about specific things I'm dealing with at the moment or just ideas I think could be useful later on.

As someone who uses [Obsidian](https://obsidian.md/) a lot, I'm sure many can relate to the constant flow of thoughts throughout the day.

So here's a simple way to capture them throughout the day. This method lets you record your thoughts without having to open Obsidian or switch around in the app.

Later on, I go through these notes at different times during the day, depending on the nature of the thought and how it relates to what I'm working on.

This Shortcut works on both iOS and MacOS devices, and appends logged items to the end of the daily note.

## Getting Started

In order to make this work, we need the following:

1. An iOS/MacOS device with the [Shortcuts](https://apps.apple.com/us/app/shortcuts/id915249334) app.
2. The [Periodic Notes](https://github.com/liamcain/obsidian-periodic-notes) or the [Daily Notes Plugin](https://help.obsidian.md/Plugins/Daily+notes).
3. Free space at the end of your daily note, just for your thoughts.

### Setup

The setup process involves a few steps, starting with getting a copy of the shortcut, which you can find here:

[Capture Thought Shortcut](https://www.icloud.com/shortcuts/aa5adb64c90d434fab5ccb0226c427a7)

How it works:

1. The shortcut prompts you to input your thoughts.
2. Once you've entered your thought, the shortcut takes the input and formats it as a bulleted item.
3. It applies a timestamp to mark when the thought was captured, which is also used to define the file path for your daily note.
4. And finally appends the input to the end of your daily note.

## Wrap up

This workflow is part of a larger productivity system using Siri Shortcuts on iOs. Feel free to copy and adapt the shortcut to your needs.