Editorial: Two threads ran through the feeds today — when models act (and how to stop them), and how humans and tools are learning to write together. Below are the top signal, concise briefs on other high‑value items, longer looks at two developer stories, and short beat notes for operators and product leads.

Top Signal

Training AI to Paint with Code

Why this matters now: The surya.website demo shows that training LLMs to output editable code sketches (not just images) can create composable, verifiable creative artifacts — a practical shift for tools that want human-in-the-loop editing, reproducibility, and predictable rewards.

“When you make an image with an AI model, the only way to participate is the prompt” — the project replaced that limitation by making code the artifact and then training for better code outputs.

Surya’s project trains a language model to emit p5.brush JavaScript sketches, renders each sketch to PNG, and uses a learned judge (pairwise human-rated comparisons) to form a reinforcement learning reward. The technical pivot is simple but important: instead of optimizing a brittle scalar proxy, they used pairwise judgments against a curated pool and evolved the system prompt, which avoided local optima like identical clip‑art flowers and pushed the model toward succinct, editable code.

Why this matters for engineering teams: code-as-output makes post‑generation verification, debugging, and incremental edits straightforward — you can lint, test, diff, and integrate generated artifacts into CI. For product managers, the experiment is a reminder that subjective objectives (aesthetics, utility) often require human-in-the-loop reward structures and reference pools, not just proxy losses.

Operational takeaway: if you’re building generative tooling, prefer artifacts that are programmatic and auditable (code, SVG, structured JSON) so you can run unit tests and drift detection; invest in curated reference sets and pairwise human judgments when the metric is taste or quality.

Source: the project write‑up.

In Brief

How universities should prepare founders (Paul Graham)

Why this matters now: Paul Graham’s essay pushes universities to stop inventing “entrepreneurship” curricula and instead create space, culture, and project time so students actually build products — a practical note for CS/engineering program leads designing experiential learning.

Graham argues the real sauce is giving students permission and time to work on projects; startups teach product skills you can’t simulate with competitions. For curriculum designers, that suggests lowering administrative barriers to student projects and encouraging credit/leave structures to let founders ship. Read the full essay.

Vintage Artificial Intelligence: playable history

Why this matters now: The Internet Archive’s curated collection surfaces how earlier software framed “thinking machines” — useful context for teams building modern AI interfaces and for product designers worried about repeating cultural mistakes around anthropomorphism.

The playable time capsule includes ELIZA ports, interactive fiction, and early agent games; it’s a crisp reminder that people have been projecting agency onto code for decades. Try the collection at the Internet Archive’s blog post and links.

Deep Dive

Emacs 31.1 lands: polish, Tree‑sitter ergonomics, and the end of the dumper

Why this matters now: Emacs 31.1 makes the editor feel materially smoother for daily development — faster startup semantics, better completion previews, and user-lisp improvements reduce friction for power users and for teams standardizing editor setups.

“But now it is finally gone for good. The end of an era.” — Emacs 31.1 notes on removing the unexec dumper.

The release trades a single flashy feature for many small but cumulative improvements: more robust Tree‑sitter integration (and automated grammar installs), a new user‑lisp directory that automates byte‑compilation and autoload wiring, and better window layout operations. Those changes mean less bootstrapping pain for teams using Emacs in Docker images or ephemeral dev containers, and fewer Tree‑sitter failures when onboarding new language modes.

For infra and tooling leads: packaging and dotfile management get easier. The user‑lisp dir encourages conventions around local packages — which reduces the “works on my machine” editor-provisioning problem. If you manage developer workstations, run a compatibility pass on critical CI tasks, but otherwise expect a net productivity gain for Emacs-heavy teams.

Read the detailed changelog and guidance at Mastering Emacs.

Moon — an interactive explainer done right

Why this matters now: The Moon interactive (Bartosz Ciechanowski) is a reminder that explainers can be both rigorous and interactive; for teams building educational UIs, it’s a practical template for making complex physics feel discoverable.

The site blends orbital mechanics, tidal physics and surface geology with manipulable visuals that make causal chains obvious — drag to change view, watch precession and see how tidal locking evolves. Beyond being a delightful walkthrough, it’s a practical study in UX for scientific content: give users affordances that map to the core causal mechanism rather than decorative controls.

If your team builds technical docs, dashboards, or data‑storytelling pages, study this interactive to learn how small JS-driven visualizations can replace long paragraphs and make correctness testable. The interactive is at ciechanow.ski/moon.

AI & Agents (short beats)

We keep building smarter agents. Almost no one builds the kill layer.

Why this matters now: The r/openclaw thread and vendor interviews underscore a recurring operational gap: teams ship agentic capabilities but lack runtime controls (kill switches, permission checks, identity attestations), creating serious security and compliance exposure.

Agent projects are no longer purely UX work — they touch identity, privilege management, and incident response. Firms shipping agents should bake an authority control plane and per-action authorization before granting network or write privileges. Source: discussion thread.

Gartner: many agent projects will fail without governance

Why this matters now: Gartner warns >40% of agent projects may be demoted or canceled by 2027 due to unclear value, rising costs and governance gaps — a pragmatic counterweight to the demo-day enthusiasm.

If you’re sponsoring pilots, require a go/no‑go checklist that includes observability, rollback procedures, and access‑control audits. (See the r/aiagents thread.)

Markets & Policy (short beats)

Wendy’s CEO admits quality slip, vows a product-first turnaround

Why this matters now: Wendy’s operational confession and turnaround plan matters for franchise operators, suppliers, and investors tracking whether product reinvestment can reverse a multi-year sales slide.

Bob Wright’s five‑point plan and takeover chatter create short-term volatility and long-term operational questions. Read more at Forbes.

Short interest can fuel rallies — retail risk remains

Why this matters now: High short interest in thinly traded names can trigger violent squeezes that create outsized retail wins and outsized losses for others; risk managers should monitor crowd signals and position concentration.

A popular Reddit thread — “Shorts are fuel” — highlights how forced cover can create rapid repricing and regulation scrutiny. See the discussion.

World (short beats)

U.S.–Canada tariff escalation and political theater

Why this matters now: President Trump’s announced 50% tariffs on Canadian autos (effective 2027) and Ottawa’s promised dollar‑for‑dollar retaliation raise near-term supply‑chain risks for North American manufacturers and consumers.

Tariff mechanics mean U.S. buyers will bear the immediate cost; cross-border producers must scenario‑plan for localized sourcing and pricing effects. Coverage at CBS News.

Dev & Open Source (short beats)

Godot, TypeScript, and the ongoing AI-contribution debate

Why this matters now: Open-source maintainers face “AI slop” in contributions; projects like Godot have tightened policies to require disclosure or block AI-authored code, forcing a rethink of contribution workflows and CI checks.

If you run OSS projects, build testable contribution policies (automated provenance metadata, stricter code review gates). See the Godot repo and related coverage at Godot on GitHub.

The Bottom Line

  • Reward design matters: subjective objectives need curated reference sets and human judgments; the Surya project is a model for reliable RL on creative tasks.
  • Ship controls with capability: agentic features must include runtime authority planes, audit trails and kill switches or you’ll pay later in incidents, cancellations, or regulation.
  • Small product improvements compound: Emacs 31.1 and interactive explainers show that thoughtful polish and testable artifacts win developer productivity and user understanding.

Sources

If you want, I can turn any single section into a short audio script or expand the agent-control checklist into a tactical runbook for engineering teams.