Adobe ends an 18-year era as AI pressure mounts

The Hook

No human could read it all — the machine can, and it does.

Today: Adobe shuts down an 18-year product line under AI pressure. Salesforce proves enterprise AI spending is producing real revenue, not just roadmap slides. And a tiny Python package called schift quietly solves one of the most painful practical ML problems — migrating embedding models without re-embedding your entire corpus.

You are about to get sharper. Let us go.

The Signal

Adobe ends an 18-year era as AI pressure mounts

Adobe has discontinued a product line that launched in 2008, citing the structural shift brought on by AI-native creative tools. This is not a quiet sunset — it is a public acknowledgment that AI compressed the viable lifespan of traditional creative software faster than even a well-resourced incumbent could adapt. For AI and ML learners, this is the clearest real-world signal of the week: the incumbents are restructuring, not just adjusting. The implication is not that Adobe is losing overall — the company has heavily invested in Firefly and Sensei — but that the pace of forced portfolio decisions is accelerating. If you are trying to understand where AI replaces versus augments existing tools, watch Adobe's next move here closely. The lesson is not specific to creative software. Every product built on a pre-AI workflow assumption is now on a forced review cycle.

Salesforce AI numbers give Benioff his swagger back

Salesforce reported AI-driven metrics showing actual revenue contribution from Agentforce and related AI features, not just pipeline projections.. This matters for practitioners because Salesforce is a leading enterprise CRM platform. When it reports real AI adoption numbers, that is not a press release — it is a dataset about how enterprises actually adopt AI at scale. Benioff has been vocal about Agentforce for months; now he has numbers to back it up. If you are studying how agentic AI gets deployed in production environments, Salesforce's architecture and adoption curve is one of the cleanest real-world case studies available right now. This is the story enterprise readers will cite in budget meetings this week.

MaxKernel: an agentic LLM generates TPU kernels

A paper out on arxiv this week introduces MaxKernel, a system where an agentic LLM generates high-performance custom kernels for TPU accelerators — a task that previously required deep hardware expertise. Writing efficient kernels for accelerators is one of the hardest things in ML infrastructure. It demands knowledge of memory hierarchy, instruction sets, and compiler behavior that takes years to acquire. MaxKernel shows an LLM handling that loop autonomously through iterative self-correction with objective performance feedback. It is not production-ready for arbitrary kernels, but the fact that it works at all in this domain is a genuine threshold crossing. We go deep on the mechanism in the DEEP DIVE section below.

schift 0.10.0 — embedding model migration without re-embedding

A new Python package called schift solves a problem every practitioner hits eventually: you want to upgrade your embedding model, but you have a corpus of millions of vectors already computed under the old model, and re-embedding everything is expensive and slow. . This is exactly the kind of practical tooling that makes real ML workflows tractable. We cover the technique in depth in ONE TECHNIQUE below, and schift is today's Tool of the Day.

Asahi Linux now runs on Apple M3

Asahi Linux, the community project that brings full Linux support to Apple Silicon, has extended to M3 chips. This drew notable community engagement on Hacker News — a strong validation signal in today's pool.. For ML developers, this is meaningful: Apple Silicon M-series chips have excellent ML acceleration via the Neural Engine, but running a Linux ML stack natively on that hardware has not been practical until now. With M3 support, more developers can run Linux-native training and inference workloads on high-efficiency hardware without virtualization overhead. A sustained community effort, with no official Apple support, reverse-engineered from scratch..

PL education in the age of AI — a contrarian voice worth hearing

Programming language researcher Shriram Krishnamurthi sat down with the Type Theory Forall podcast to challenge consensus assumptions about AI and education. His concern: AI autocomplete and generation tools short-circuit the productive struggle that builds genuine mental models. For anyone learning AI and ML fundamentals, this is worth internalizing. The discomfort of not understanding something immediately is not a bug in your learning process — it is the process. Use AI tools to check your work and get unstuck, not to avoid the work entirely. Krishnamurthi's argument is a useful corrective to the idea that AI tools uniformly accelerate learning.

APLAUD: per-user LoRA fine-tuning for personalized LLM prediction

A new arxiv paper proposes APLAUD, adaptive personalized low-rank decomposition — essentially, per-user LoRA fine-tuning of an LLM for survey response prediction. Standard fine-tuning optimizes for the average of all users, but personalization tasks require capturing individual variation. APLAUD decomposes the fine-tuning problem per-user using low-rank adapters fitted on shared base weights, keeping compute tractable while capturing individual differences. The paper demonstrates clear gains on personalized prediction tasks. This is a clean entry point for learners studying LoRA — our LEARNER'S EDGE section today covers exactly that concept, motivated by this paper.

Genius AI Detector — AI output detection tooling enters the market

A tool called Genius AI Detector launched this week, positioned as an AI-output detection product. The space is real — educators, publishers, and employers all have a genuine need to understand whether content was AI-generated. Detection accuracy in this category varies widely, and the field has no settled benchmark. Treat any detection tool as probabilistic signal, not a verdict. What is useful here is the reminder that AI detection is an active research and product category, with direct implications for how you document and attribute your own AI-assisted work going forward.

Quick Hits

• Genius AI Detector — AI output detection is a real product category now; treat any tool in this space as probabilistic signal, not a verdict, until the field establishes a benchmark.
• APLAUD paper (arXiv:2609.04738) — per-user LoRA decomposition is a clean entry point for understanding personalized fine-tuning; this direction is heating up across the frontier-research lane.
• Shriram Krishnamurthi on AI and PL education — one of the sharpest contrarian voices on what AI does to learning; the Type Theory Forall episode is worth your commute.
• Asahi Linux M3 — native Linux on Apple Silicon M3 is now real; if you run ML workloads on Apple hardware and have been waiting, the wait is over.

The Cold Open

Picture the conference room at Adobe circa 2008. A product is born. Eighteen years of roadmap meetings follow — feature releases, designer feedback loops, enterprise contracts stacked on top of each other. Then, in 2026, a model that did not exist five years ago quietly makes the entire business case collapse.

This is not a disruption story from a textbook. It is happening now, in real companies, to real product lines. The question for anyone building AI skills today is not whether your tools will be disrupted. It is whether you will understand the disruption well enough to navigate it before it reaches you.

Good morning. Let us get you there.

The Anchor

Adobe's 18-Year Sunset Is the Enterprise AI Story Everyone Missed

When a company kills a product line, the press release usually says something about strategic focus. Adobe's discontinuation of an 18-year-old product suite says something more specific: AI changed the competitive calculus so fast that even a well-resourced, AI-investing incumbent could not adapt a specific product line in time.

Here is the context that matters. Adobe has not been sleeping on AI. Firefly, its generative image model, is genuinely competitive. Sensei has been embedded in Adobe's products for years. The company has spent aggressively on AI infrastructure and made real bets. And yet — a product line built over 18 years of investment became economically unviable in a single AI cycle.

What does that tell us? A few things worth unpacking carefully. First, the disruption is not symmetric. Adobe's AI investments may ultimately strengthen its core Creative Cloud business. But the products designed for an older workflow assumption — that creative work is mostly human-executed with software as the instrument — cannot survive when AI drops the marginal cost of that execution toward zero. The product was not bad. The assumption underneath it was no longer true.

Second, the timeline compressed. Eighteen years of product development, enterprise relationships, and institutional knowledge — rendered obsolete at a pace that the original product roadmaps could not have anticipated. This is the pattern playing out across industries: not a slow fade, but a forced restructuring when the inflection point hits. The companies that assumed they had five years to adapt are discovering they had two.

Third, and most importantly for this newsletter's readers: the people who understand how AI substitution actually works — technically, economically, and in terms of workflow mechanics — are the ones best positioned to navigate it. Not because they predicted it, but because they can read the signal while others are still processing the announcement.

Adobe will survive this. The company is adapting, not dying. The lesson is not 'Adobe is losing.' The lesson is: every product built on a pre-AI workflow assumption is now on a forced review cycle. Know which category your work falls into. Act before the announcement, not after it.

Deep Dive

MaxKernel: How an LLM Generates TPU Kernels — and Why the Loop Is the Innovation

Let us start with what writing a TPU kernel actually requires. A Tensor Processing Unit is Google's custom accelerator for ML workloads. Unlike a GPU, where you write CUDA and rely on libraries like cuDNN to abstract the hardware, TPU programming requires you to reason explicitly about the accelerator's memory hierarchy — the difference between HBM and on-chip VMEM, how data tiles move through the systolic array, how to keep all compute units saturated without stalling on memory. It demands knowledge of compiler behavior, tile sizing, and instruction scheduling that takes years of specialized practice to develop. Most ML teams do not write custom TPU kernels at all. They rely on XLA, JAX, and pre-built ops because the expertise required is genuinely rare.

MaxKernel changes the loop. The system uses an agentic LLM — not a one-shot code generator, but an iterative agent that can observe the output of its own generated code, profile performance, and revise. The architecture works roughly like this: the agent receives a specification of what operation to implement and on what input shapes. It generates a candidate kernel. The kernel is compiled and run. A performance benchmark compares the result against a reference. The agent reads the profiler output and revises. It iterates until performance converges or a budget is exhausted.

Why does this agentic loop work when simpler one-shot code generation fails? Three reasons. First, kernel correctness is verifiable in a tight feedback loop — you can run the kernel and compare its output to a reference implementation. This gives the agent a clean, ground-truth signal it cannot get in domains where correctness is ambiguous. Second, the iterative structure lets the model recover from common failure modes — wrong tile sizes, inefficient memory access patterns, suboptimal vectorization — by reading profiler output and making targeted revisions rather than random perturbations. Third, the LLM has internalized enough hardware knowledge from training data to make those revisions meaningfully, not blindly.

What is genuinely novel here is not that an LLM can write code. We already knew that. It is that an LLM can write code in a domain where the evaluation signal is objective and tight enough to drive real, measurable improvement across iterations. The agentic loop plus objective feedback is the unlock — and that pattern will appear in more domains over the next 12 months.

The honest limitations: MaxKernel works best for operations with clean mathematical structure — matrix multiply variants, reductions, element-wise operations. Irregular memory access patterns and complex control flow remain hard. The kernels it generates are sometimes not as good as what an expert human would produce. But 'sometimes almost as good as a hardware expert, without the hardware expert' is a remarkable result. The paper is arXiv:2609.04523 for anyone who wants the full architecture.

One Technique

Embedding Space Bridging: Migrate Models Without Re-Embedding Your Corpus

The problem is one you will hit eventually: you have a RAG pipeline or semantic search system trained on embeddings from model A. Model B is better, faster, and cheaper. But your corpus has millions of vectors computed with model A, and re-embedding everything costs time and money you do not have right now.

The technique is called embedding space bridging. Instead of recomputing all vectors from scratch, you learn a linear mapping from the old embedding space to the new one. The process has three steps. First, build an alignment set: take a sample of documents — a few hundred to a few thousand — and embed them with both models. Second, fit a transformation matrix that minimizes the distance between the two embedding spaces on that sample. Third, apply the transformation to all your existing vectors, projecting them into the new model's space.

The result: your old corpus, projected into the new model's space, with good-enough fidelity for most retrieval tasks — without paying the full re-embedding cost. Quality degrades gracefully as your corpus drifts further from the alignment sample, so monitor retrieval metrics after migration rather than assuming the bridge holds everywhere.

When to use it: RAG pipelines, semantic search, any vector database with a large existing corpus. When you upgrade your embedding model, reach for a bridging approach before budgeting a full recompute. schift 0.10.0 implements this pattern as an SDK.

One Prompt

Use this prompt before touching any embedding migration tooling — it will tell you whether a bridging approach is right for your situation:

You are a patient ML tutor. I have a corpus of documents embedded with [OLD MODEL NAME]. I am considering migrating to [NEW MODEL NAME].
Walk me through:
1. What specifically changes between these two embedding spaces — dimensionality, training objective, tokenization approach if relevant.
2. Whether a linear bridging transform is likely to work well for my use case, or whether I should budget a full recompute instead.
3. How to build a minimal alignment test set to evaluate the migration quality before committing.
Keep each answer to 3-5 sentences. Be honest about uncertainty — if you do not know whether the bridge will generalize well, say so.

Replace the bracketed placeholders with your actual model names. Run this before you write a single line of migration code. It will surface the cases where bridging is not the right call — and that will save you more time than the technique itself.

One Tip

Always embed a canary document before and after any model migration.

Pick one document from your corpus whose retrieval behavior you know well — a document where you know exactly what queries should surface it and what queries should not. Embed it with both the old and new model (or the bridged vector), run your known queries, and compare the rankings side by side. This takes five minutes. It tells you immediately whether the migration preserved the semantics that matter to your use case. If the canary's ranking degrades on your known queries, your bridge is not generalizing well for your domain — stop and reassess before touching production.

Tool of the Day

schift 0.10.0

pip install schift

schift is a Python SDK for embedding model migration. Its core function is fitting a bridging transform between two embedding spaces so you can migrate an existing vector corpus — a RAG index, a semantic search database, any pre-computed vector store — without a full recomputation. You point it at a sample of your documents, it fits the alignment transform, and you apply it to the rest of your corpus.

Genuinely good for: RAG pipelines, semantic search databases, and any system with a large pre-computed vector store that needs to track a better embedding model on a budget of time or compute.

Honest limit: The bridging quality depends on how similar the two embedding spaces are architecturally. Migrating between models with very different training objectives or very different dimensionality may not generalize well across all domains of your corpus. Audit retrieval quality after migration — do not assume the bridge holds everywhere without checking.

Signature Bites

• The premise failed, not the product. Adobe's 18-year sunset was not a quality failure — the workflow assumption underneath the product became obsolete. That is a completely different kind of vulnerability.
• Objective feedback is the agentic unlock. MaxKernel works because kernel correctness is verifiable in a tight loop. The agentic structure plus objective evaluation signal — that pattern will appear in more domains.
• The productive struggle is the process. Krishnamurthi's warning: AI autocomplete short-circuits the discomfort that builds real mental models. Use AI to check your work, not to avoid doing it.
• Bridge before you recompute. The next time you want to upgrade your embedding model, reach for a bridging transform before budgeting a full corpus recompute. schift makes this a pip install.

Joke of the Day

A junior ML engineer walks into a sprint review and announces: 'Good news — I migrated our entire vector database to the new embedding model overnight.'

The senior engineer asks: 'Did you validate retrieval quality afterward?'

The junior says: 'The cosine similarities all look great.'

The senior engineer says: 'So did the old ones.'

Fact of the Day

The Asahi Linux project began by targeting Apple M1 chips.. It took years of community development — with no official support from Apple — to reach M3.. The team reverse-engineered Apple's GPU drivers and Neural Engine interfaces entirely from scratch, working from hardware documentation that Apple never published. It is widely regarded as one of the most ambitious open-source hardware reverse-engineering efforts in recent memory..

Stat That Matters

The Asahi Linux M3 announcement received the strongest community-validation signal in this issue's story pool..

Why it matters: HN upvotes are a noisy signal in isolation, but 246 points in the ML and systems developer community is meaningful validation that a genuine capability gap has been closed. ML developers on Apple Silicon have wanted native Linux for years. The community response confirms this is not a niche announcement — it is a workflow unlock for a real segment of practitioners who have been waiting.

Trends

The agentic-AI lane was the busiest in today's pool by a wide margin.. MaxKernel is the most technically interesting example, but the volume is the signal: agentic systems are no longer a research topic. They are the dominant theme in the field, and the stories are starting to involve real deployments, not just papers.

, with Salesforce as the most credible enterprise proof point. The pattern emerging across earnings calls: AI revenue is showing up as a line item, not just a roadmap promise. The narrative is shifting from 'AI will pay off eventually' to 'AI paid off this quarter.'

Frontier research is converging on personalization as a live direction. — APLAUD is one of several papers this week treating per-user adaptation as a tractable engineering problem, not a research aspiration. Watch this space.

Bold Prediction

Within 18 months, at least one major cloud provider will offer a managed embedding migration service — a hosted version of what schift does today — as a standard feature bundled into their vector database product. The pain point is real and well-documented. The tooling is currently nascent and fragmented. The RAG infrastructure market is large enough to justify productization. Mark this prediction: embedding migration goes from a bespoke engineering project to a checkbox feature in your cloud provider's vector DB console.

Paper Watch

APLAUD: Adaptive Personalized Low-Rank Decomposition for User-Specific LLM Fine-Tuning

arXiv:2609.04738 — This paper tackles a real limitation of standard fine-tuning: when you fine-tune an LLM on a dataset, you optimize for the average behavior across all users in the training set. For tasks where individual variation is meaningful — like predicting how a specific person will respond to a survey question — the average is wrong for most individuals most of the time.

APLAUD's approach: use LoRA-style low-rank adapters, but fit a separate adapter per user on top of shared base weights. Each user gets a personalized adapter that captures their individual response patterns without requiring a full fine-tuning run per person. The shared base keeps compute tractable; the per-user adapters handle the individual variation.

The paper demonstrates clear quality gains on personalized survey prediction tasks compared to both shared fine-tuning and no fine-tuning baselines. For learners: this is one of the cleanest examples of LoRA being applied to a personalization problem rather than the more common domain adaptation use case. If you are building toward real fine-tuning fluency, read it alongside the LEARNER'S EDGE section today.

Founder Spotlight

Marc Benioff, Salesforce

The strategic move this week is not a product launch — it is a narrative reclaim. Benioff has been leading with Agentforce, in the face of sustained skepticism about whether AI revenue was real or just marketing motion.. This week's numbers give him a defensible answer in an earnings context.

The move worth watching: Salesforce is positioning Agentforce not as a chatbot layer bolted onto CRM, but as a production agentic system embedded in enterprise workflows. If the adoption curve holds, Salesforce becomes the largest real-world dataset for how agentic AI actually deploys at enterprise scale — in messy, legacy-integrated, compliance-heavy environments where most AI demos do not survive contact with reality. That is a moat smaller AI companies cannot easily replicate, and it is worth watching how Benioff continues to build it.

Quote

'Designing and authoring high-performance custom kernels for accelerators is a complex task that requires deep hardware-level expertise.'

— MaxKernel paper abstract, arXiv:2609.04523

The paper then proceeds to show an LLM doing it. The gap between that opening sentence and the conclusion is the entire story.

Learner's Edge

What is LoRA — and why does it matter for fine-tuning?

Low-Rank Adaptation (LoRA) is a technique for fine-tuning large language models without updating all of the model's billions of parameters. Here is how it works: you freeze the original model weights completely, and add small trainable matrices — called adapters — alongside specific layers in the network. These adapter matrices are low-rank, meaning they have far fewer dimensions than the original weight matrices. The number of trainable parameters drops dramatically compared to full fine-tuning..

Why does this matter? Fine-tuning a 7-billion-parameter model from scratch requires enormous GPU memory and compute time. LoRA lets you adapt the same model to a new task or domain with a fraction of those resources. You can swap different LoRA adapters in and out at inference time, giving you multiple specialized versions of the same base model without storing separate full copies.

Today's APLAUD paper applies this directly: per-user LoRA adapters for personalized prediction, all sharing the same base model. Next time you see a paper mention 'LoRA' or 'adapter-based fine-tuning,' you now know the mechanism underneath it.

Sign-off

That is The Agent Signal for September 7, 2026. Tomorrow we are watching how Salesforce's Agentforce adoption numbers hold up as more enterprise reports come in — and whether the MaxKernel agentic kernel approach starts appearing in production ML infrastructure announcements. Stay curious, keep building your fundamentals one concept at a time, and we will see you tomorrow.

Sources

1. Adobe ends an 18-year era as AI pressure mounts — TheStreet
2. Salesforce (CRM)’s AI Numbers Just Gave Benioff His Swagger Back — Insider Monkey
3. MaxKernel: Agentic Kernel Generation for TPUs — arxiv.org
4. schift 0.10.0 — pypi.org
5. Asahi Linux on M3 — asahilinux.org
6. PL Education in the Age of AI: Interview with Shriram Krishnamurthi — typetheoryforall.com
7. Aplaud: Adaptive Personalized Low-Rank Decomposition for User-Specific LLM — arxiv.org
8. Genius AI Detector — geniusaidetector.com