vibe-coding on S Anand

My changing AI opinions

Fri, 05 Jun 2026 09:41:33 +0800

I asked Claude about my AI opinions.

Based on my transcripts and blog posts, find the three claims I make most consistently, the three I’ve quietly reversed, and the one assumption I’ve never questioned but everything depends on.

Here are things I’ve changed my opinion on:

THEN: One frontier model will win - not specialization. NOW: Gemini for media, Claude for strategy/style, GPT for rigor. SLMs as tools.
THEN: Carefully curate my course content. NOW: Give students prompts directly.
THEN: Web apps are differentiated artifacts. NOW: HTML is easier to generate than PPT - a signal of slop, not craft.
THEN: Human in the loop. NOW: Human NOT in the loop, bottlenecking it. On-the-loop, etc. is fine.
THEN: Minimal single-agent loop, avoid sub-agents" NOW: Multi-agent, sub-agent, and agent teams.
THEN: Avoid MCP, prefer SKILLS.md. NOW: Use MCP because integrating with Claude / ChatGPT / … is easy.

There are the top contradictions in my opinions.

“Vibe code everything, end-to-end” vs “Don’t commit based on vibe-coding, it’s not fully reliable”.
“Experience is a liability” vs “Domain expertise is an edge”
“Paid plans are fine for private data” vs “Don’t assume paid = private”
“Get out of the way / delegate everything” vs “Verification is the whole job”
“Build, don’t plan” vs “Plan → Correct → Execute”

Some things, I have never questioned.

For numbers, math, or correctness, make AI write and run code – never trust prose arithmetic.
Judge AI against human accuracy, never against perfection – because experts disagree among themselves.
Use AI heavily – reach for it first, high volume.
Don’t build a foundation model from scratch – steer existing general models instead.

Things I usually say, but there are exceptions.

“Always verify”. But blindly trust AI in non-core areas where you are unskilled (such as personal finance).
“AI is improving fast”. But there is a jagged edge, to verify before upgrading.
“Don’t build models”. But go ahead if it’s easy and beats LLMs clearly.
“Models keep getting cheaper”. But not in May 2026.

Things I Learned - 29 Mar 2026

Sun, 29 Mar 2026 00:00:00 +0000

This week, I learned:

The Kids Should See This - great collection of videos for curious people. Thej
A jury fined Meta and YouTube $4.2m and $1.8m for building addictive features in their products. That’s a first. NY Times
“I think AI-type tools will actually revolutionize the experimental side of math, where you don’t care so much about individual problems and the process of solving them, but you want to gather large-scale data about what things work and what things don’t.” Terence Tao
The hedonic treadmill (which roughly quantifies a Buddhist principle) says that we revert to a happiness set point (which varies by individual). Worse, those who experience a high kick (e.g. a lottery) don’t get enough kick from normal wins (contrast effect) – Interactive explainer. The happiness neutral
As of today, a LinkedIn search for “llm psychologist” lists 9 people. I’m not alone!
- Anand S, LLM Psychologist, Singapore, Singapore
- Anshul Saxena, PhD, AI Advisor & Trainer | Technology Strategist | LLM Psychologist | Currently teaching humans, machines & business to work smarter through Generative AI and Quantum Computing | 15+ Years Experience, Pune, Maharashtra, India
- Charitarth (Chad) Sindhu, LLM Psychologist / Fractional Business & AI Workflow Consultant/ Digital Nomad, Tokyo, Japan
- Lancelot Salavert, LLM Psychologist, Barcelona, Catalonia, Spain
- Lior Dor(Durahly), Team Lead | Bug Banisher | Ex 8200, Tel Aviv District, Israel. Past: R&D Team Lead and LLM Psychologist at Superwise | A Blattner Tech Company
- maxime bodereau, Lead Creative Art Director | UX Forensics | Ai LLM Psychologist | Visual Alchemist | Codesmith | Brandologist | Full Stack Designer, Nantes, Pays de la Loire, France
- Mei Chen 🦋, LLM Psychologist | Lead Product Engineer | Delivering Agentic Experiences, Toronto, Ontario, Canada
- Shoshannah Tekofsky, LLM Psychologist at AI Digest, Zwolle, Overijssel, Netherlands
- LinkedIn Member, LLM, psychologist, mediator, Prague, Czechia
OpenAI acquired Astral!. This will likely slow down the new wonderful tools accelerating the Python ecosystem. Like with PromptFoo and OpenClaw, this seems to be about talent. The “acqui-hire” mode seems a clear niche career path now, and an alternative to getting hired (you get a much higher salary) or getting acquired (you take on much higher risk).
quickjs-emscripten lets you run isolated JS code securely in the browser, CloudFlare workers, NodeJS, and Deno. It compiles to WASM. @sebastianwessel/quickjs is a higher-level TS wrapper. Simon Willison
Manyana is a CRDT based version control system. It sounds like a good idea but I’m sceptical because merge conflicts are a “what should I do” problem more than “how”. With agents doing more merge conflict management, I am not sure this will offer a concrete benefit - but probably no harm either.
LLMs are able post-train LLMs on new topics. They’re improving fast. Jack Clark
Vibe Coding Fixer and AI Slop Cleaner are real job descriptions - which are morphing into enterprise offerings. But I still seem to be the only official LLM Psychologist
Notes from AI Services - Wrong Mental Models, Right Moment:
- AI services has 3 markets. Automatable work: vanishes in 2 years. Human-in-the-loop work: sustains. Judgement-driven: grows in importance.
- YC: don’t sell access to a tool for $50 a month, use the AI yourself and sell the finished work for $5,000.
- Sell output. Price on outcome. Sell to business, not IT.
- Sell accountability: proven success, with your guarantee.
- Sell authenticity: a brand story representing uniqueness, character, … or whatever… something people respect.
Data transfer between GPU and memory is a bottleck and three approaches are emerging. #
- Taalas is etching LLMs into the chip. Llama 8b runs at 17,000 tok/s (H200 is at 230 tok/s).
- d-Matrix is moving compute into SRAM memory chips. 30,000 tok/s for Llama 70b. Cerebras and MatX are similar: memory-oriented.
- FuriosaAI minimizes data movement. Groq and Sambanova are similar.
- But in the long run, commodity technology usually beats integrated stacks.
GPT 5.4 Nano ($0.2/MTok) and Mini ($0.75/MTok) are good options for bulk OCR, transcription, etc. as cost and quality comparable alternatives to Gemini Flash Lite and Gemini Flash. They can describe 75K photos for $50. Both models are better than GPT-5 Mini on most benchmarks.
Cool AI coding agent git prompt fragments:
- Use git bisect to find when this bug was introduced: …
- Find and recover my code that does …
- Sort out this git mess for me.
- Rewrite history removing …
- Split the last commit into multiple commits grouped logically.
- Start a new repo at … and build just this module … based on … with a similar commit history copying the author and commit dates.
Campaigns Are Knowledge Workers and the Tools Just Caught Up. A powerful framing. I saw this in action a few days ago when a friend was able to automate an outbound campaign with Claude Code.
EARS (Easy Approach to Requirements Syntax) is a simple structure for requirements. For example, “Users should be able to drag tasks between columns. The app needs to work offline too. Handle errors gracefully.” becomes the following - which AI can convert to and is easier to spot errors in. State machines and decision tables are useful alternatives, too.
- REQ-001 (Event): When the user drags a task card to a different column, the system shall update the task status to match the destination column.
- REQ-002 (State): While the application is offline, the system shall store task updates in local storage.
- REQ-003 (Event): When the application reconnects, the system shall synchronize locally stored updates with the server.
- REQ-004 (Unwanted): If synchronization conflicts occur, then the system shall display a resolution dialog to the user.
As of now, avoid using Claude.ai to create (large) visualizations. It runs forever and exhausts credits without generating anything. Claude Code works much better for this.

The Nov 2025 Vibe Coding Ghost Revolution

Mon, 23 Mar 2026 11:21:42 +0530

I kept hearing that with the Nov 2025 release of Opus 4.5 and GPT 5.2 Codex, ex-coders were sprinting back to coding.

On a sample of ~1,700 developers on GitHub, exactly ten fit the “dormant returner” profile.

Here are a couple of examples:

But they’re the exception. I could find only TEN out of 1,700 developers who returned. I also found a few who exited:

To be fair, the vibe coding revolution is real, but maybe we are (I am) mis-interpreting it.

There are lots of new non-developers joining GitHub. Anecdotally, Naveen Gattu (finally!!) and Ankor Rai
A few high-profile ex-developers are returning and are very active. Anecdotally, Sebastian Siemiatkowski
But the majority of the developers who were less active last year remain less active.

Read the full analysis.

Live Vibe Coding using Others' Ideas

Sat, 21 Mar 2026 22:51:50 +0530

I spoke today on Design in the Age of Infinite Generativity at the Chennai Design Festival.

You can read about the talk in the link about. This post is about my preparation.

Tue 10 Mar 2026. Damn! Palani’s asked for the topic. Claude, what should I talk about!?
Fri 20 Mar 2026. ChatGPT, tell me who the other speaker are.
Fri 20 Mar 2026. Oh, I’ll just pull a bunch of links, use browser tabs as slides, create some slide dividers, and I’m ready!
Sat 21 Mar 2026 1:00 pm. I’m NOT ready! The story doesn’t flow. It’s rubbish.
Sat 21 Mar 2026 3:00 pm. Let me drop some of the boring ones. I just have 15 minutes.
Sat 22 Mar 2026 3:30 pm. Oh, maybe I should listen to what the others are saying, just… you know…

… and that proved the best decision ever, because Senthil of Payir showed a re-usable fabric calendar that converts into a bag. It was a fantastic idea, so I got curious.

3:40 pm. Asked Claude for more ideas like Senthil’s. It looked fine and I could read it later, but what if… maybe… I presented these ideas!?
3:45 pm. Ask Gemini to draw the first idea - a Modular Kolam Mat. The results look fantastic!
3:50 pm. Now I’m going ga-ga over the idea. I generate images for 3 more ideas: a growth chart kurta, seed library sari border, and recipe towel.
4:15 pm. Narendra shares a bunch of cool PsychOps design hacks like:
- When lights are dimmed people speak softer. So, dimming lights reduces sound levels in noisy offices.
- Rather than reduce the size of shampoo sachets (which customers and business both hate), include 2 shampoos in one sachet, tearable in the middle.
- Price saches at 95p with a 5p deposit for the sachet - which rag-pickers can collect and return to the retailer.
4:20 pm. Ask Claude for more ideas like Narendra’s. The results are just as fantastic!
4:30 pm. I now have images for his ideas too. Now, I start deleting my more boring links.

In fact, these ideas ended up being so good that the bulk of my talk was just about ideas derived from their work. (I’m obviously a big fan of plagiarism!)

Despite being one of my shortest talks (~10 min), this worked quite well because people value speed and spontaneity. I was obviously demonstrating these and that felt cool.

For many years, I’ve been live-coding on stage. But that requires a lot of preparation.

Vibe-coding makes live-coding a lot faster. I can do it during a client demo. I can do it during a talk.

So, I’m going to listen more to what others are saying (in meetings, conferences, etc.) and live-vibe-code from what they just said. Great way to show-off while learning from others!

26 Mar 2026: On a related note, AI has better product development ideas than humans. Read Serendipity by Design: Evaluating the Impact of Cross-domain Mappings on Human and LLM Creativity

Protyping the prototypes

Tue, 10 Mar 2026 12:17:47 +0800

I added a narrative story to my LLM Pricing chart. That makes it easier for me and others to tell the story of AI’s evolution in the last three years.

Video

It was vibe-coded over two iterations.

In the first version, I prompted it to:

Add a scrollytelling narrative. So, when users first visit the page, they see roughly the same thing as now (but prettier). As they scroll down, the page should smoothly move to the earliest month, and then animate month by month on scroll, and explaining the key events and insights in terms of model quality and pricing. Use the data story skill to do this effectively, narrating like Malcolm Gladwell, with the visual style of The New York Times, using the education progression as a framework for measure of intelligence (read prompts.md for context). Store the narrative text in a separate JSON file and read from it. This should control the entire narrative, including what month to jump to next, what models to highlight, what insights to share, and so on.

But there were two problems:

Conflicting instructions. “… with the visual style of The New York Times” conflicted with my current style.
Incomplete instructions. I wanted to begin with the exploration, not the narrative. I wanted to explain the axes first. I wanted smaller cards.

Both of them were solved in the second version, because this time, I knew what I wanted.

In other words, vibe coding isn’t just helping me prototype, it’s helping me prototype the prototype! Even if I don’t know what I want, I can just ask for something and build on it.

This is a known benefit of lower costs. But, like the placebo effect and Hofstadter’s Law, I’m surprised by it even when I know it.

An aside: Here’s the narrative it crafted:

How to read this chart: The vertical axis is intelligence — mapped to the academic ladder on the right. Elo 1100 is high school freshman; Elo 1480 is tenured professor. The horizontal axis is cost: one million input tokens — roughly the entire King James Bible — priced from two cents to $75. The upper-left corner is the dream: brilliant and cheap. This is the story of how the world got there.
March 2023 — Year Zero: March 2023. The entire AI landscape fits in a small cluster near the bottom of the chart. GPT-3.5 and Claude 1 are the state of the art — high-school-to-college-freshman intelligence that writes a fluent paragraph, then confidently invents a fact. Processing the King James Bible costs 50 cents to $8. These models can hold a conversation. They cannot, reliably, hold an argument. LMSYS Chatbot Arena launches (May 2023)
November 2023 — The Leap: November 6, 2023: GPT-4 Turbo. The chart jolts upward. Elo 1313 — college-junior level: coherent research papers, complex reasoning, output worth reading. Price: $10 per million tokens — about $14 to process all seven Harry Potter novels. Expensive, but for the first time the intelligence felt worth it. Enterprises stopped asking whether AI could help. They started asking how much they were willing to pay. OpenAI DevDay announcement
February 2024 — The Split: Early 2024: Anthropic launches Claude 3 in three tiers. Opus and Sonnet arrive February 29; Haiku a week later, March 7. Opus: entry-analyst capability at $15. Sonnet: similar quality at $3. Haiku: college-junior reasoning at $0.25. A 60× price spread — same company, same training philosophy. The intelligence market had learned to stratify, and every business began thinking in tiers. Anthropic Claude 3 announcement
June 2024 — The Summer Pivot: June 2024 bent the economics permanently. Claude 3.5 Sonnet — strong manager level (Elo 1342) — arrived at $3 per million tokens: five times cheaper than Opus, four months later, at better quality. Meta’s Llama 3.1 405B matched it at $2, or free if self-hosted. Any CFO paying $15 for frontier AI could now pay $3. The question changed from “can we afford AI?” to “what are we waiting for?” Claude 3.5 Sonnet launch, Meta releases Llama 3.1
September 2024 — The Thinking Machine: September 2024: OpenAI o1. It didn’t just answer — it reasoned. Before responding, it ran an internal monologue: checking its own logic, catching its own errors. Elo 1388 — the biggest single-model quality jump since GPT-4. It scored at or above PhD-expert level on GPQA Diamond, a benchmark of graduate-level science questions. Price: $15. For the first time, AI felt less like autocomplete and more like a colleague you’d genuinely consult. OpenAI o1 system card, GPQA Diamond benchmark results
January 2025 — The Earthquake: January 20, 2025. DeepSeek R1 matched o1-level reasoning (Elo 1398) at $0.55 per million tokens — a 27× discount. The announcement wiped $600 billion from Nvidia’s market cap in a single day. Silicon Valley assumed expensive compute was a moat. DeepSeek proved it was just a starting point. PhD-approaching reasoning for fifty-five cents per Bible. Reuters: DeepSeek wipes $600B from Nvidia, DeepSeek R1 technical report
Mid-2025 — The Race to the Top-Left: By mid-2025, the upper-left corner was filling fast. Gemini 2.5 Pro delivered tenured-professor intelligence (Elo 1476) at $1.25 per million tokens. Flash models handled most enterprise work for 30 cents. Companies that had rationed AI to critical workflows were now running it everywhere. The constraint was no longer cost or capability — it was imagination. Google Gemini 2.5 Pro launch
February 2026 — Polymath Scholar: The top models in early 2026 score above 1500 Elo — polymath scholar territory. A 1500-rated model beats a 1300-rated one in 76% of head-to-head matchups. GPT-4 Turbo launched at college-junior level (Elo 1313) in November 2023. Twenty-seven months later, Claude Opus 4.6 and Gemini 3.1 Pro sit at 1500+. What cost $15 in 2024 is now beaten by models at one-seventh the price. LMArena Leaderboard
So What Does This Mean?: In 2023, reaching master’s-level AI for 100 analysts meant paying $30/MTok — roughly $135,000 a month. By 2026, models with higher capability cost $1–5/MTok: under $15,000 for better results. For most tasks — analysis, drafting, coding, research — models in the $1–3 range deliver more than enough. Save frontier models for your hardest problems. The question is no longer what AI costs. It’s what you would build if intelligence cost a dime per Bible. McKinsey: The economic potential of generative AI, Sequoia: AI’s $600B question

Self-referentially, my answer to its last question: “what you would build if intelligence cost a dime per Bible” is “a scrollytelling narrative about intellegince costing a dime per Bible”.

AWS PartyRock

Thu, 22 Jan 2026 21:22:31 +0530

I tried vibe-code a CSV to colored HTML table converter using this prompt.

Create a tool that can convert pasted tables into colored HTML tables.
Allow the user to paste a CSV or tab-delimited or pipe-delimited table.
…
Create an HTML table that has minimal styling.
…
Add a button to copy just the HTML to the clipboard.

Codex built this. Which is perfect.

AWS Partyrock built this. Which is a joke, because it didn’t write the code to do the conversion. It uses an LLM every time.

The good part, though, is that it builds UI components that you can edit and move around.

I think it builds a domain specific language with components with properties. You can edit the properties to change the app.

This is a good way to build robust apps using unreliable LLMs. But it has less flexibility and richness.

With LLMs becoming more and more reliable, I think generating code directly is better, and this approach will fade or be used in niches.

NPTEL Applied Vibe Coding Workshop

Sun, 11 Jan 2026 22:53:28 +0800

For those who missed my Applied Vibe Coding Workshop at NPTEL, here’s the video:

You can also:

Or, here are the three dozen lessons from the workshop:

Definition: Vibe coding is building apps by talking to a computer instead of typing thousands of lines of code.
Foundational Mindset Lessons
1. “In a workshop, you do the work” - Learning happens through doing, not watching.
2. “If I say something and AI says something, trust it, don’t trust me” - For factual information, defer to AI over human intuition.
3. “Don’t ever be stuck anywhere because you have something that can give you the answer to almost any question” - AI eliminates traditional blockers.
4. “Imagination becomes the bottleneck” - Execution is cheap; knowing what to build is the constraint.
5. “Doing becomes less important than knowing what to do” - Strategic thinking outweighs tactical execution.
6. “You don’t have to settle for one option. You can have 20 options” - AI makes parallel exploration cheap.
Practical Vibe Coding Lessons
1. Success metric: “Aim for 10 applications in a 1-2 hour workshop” - Volume and iteration over perfection.
2. The subscription vs. platform distinction: “Your subscriptions provide the brains to write code, but don’t give you tools to host and turn it into a live working app instantly.”
3. Add documentation for users: First-time users need visual guides or onboarding flows.
4. Error fixing success rate: “About one in three times” fixing errors works. “If it doesn’t work twice, start again-sometimes the same prompt in a different tab works.”
5. Planning mode before complex builds: “Do some research. Find out what kind of application along this theme can be really useful and why. Give me three or four options.”
6. Ask “Do I need an app, or can the chatbot do it?” - Sometimes direct AI conversation beats building an app.
7. Local HTML files work: “Just give me a single HTML file… opening it in my browser should work” - No deployment infrastructure needed.
8. “The skill we are learning is how to learn” - Specific tool knowledge is temporary; meta-learning is permanent.
Vibe Analysis Lessons
1. “The most interesting data sets are our own data” - Personal data beats sample datasets.
2. Accessible personal datasets:
  - WhatsApp chat exports
  - Netflix viewing history (Account > Viewing Activity > Download All)
  - Local file inventory (ls -R or equivalent)
  - Bank/credit card statements
  - Screen time data (screenshot > AI digitization)
3. ChatGPT’s hidden built-in tools: FFmpeg (audio/video), ImageMagick (images), Poppler (PDFs)
4. “Code as art form” - Algorithmic art (Mandelbrot, fractals, Conway’s Game of Life) can be AI-generated and run automatically.
5. “Data stories vs dashboards”: “A dashboard is basically when we don’t know what we want.” Direct questions get better answers than open-ended visualization.
Prompting Wisdom
1. Analysis prompt framework: “Analyze data like an investigative journalist” - find surprising insights that make people say “Wait, really?”
2. Cross-check prompt: “Check with real world. Check if you’ve made a mistake. Check for bias. Check for common mistakes humans make.”
3. Visualization prompt: “Write as a narrative-driven data story. Write like Malcolm Gladwell. Draw like the New York Times data visualization team.”
4. “20 years of experience” - Effective prompts require domain expertise condensed into instructions.
Security & Governance
1. Simon Willison’s “Lethal Trifecta”: Private data + External communication + Untrusted content = Security risk. Pick any two, never all three.
2. “What constitutes untrusted content is very broad” - Downloaded PDFs, copy-pasted content, even AI-generated text may contain hidden instructions.
3. Same governance as human code: “If you know what a lead developer would do to check junior developer code, do that.”
4. Treat AI like an intern: “The way I treat AI is exactly the way I treat an intern or junior developer.”
Business & Career Implications
1. “Social skills have a higher uplift on salary than math or engineering skills” - Research finding from mid-80s/90s onward.
2. Differentiation challenge: “If you can vibe code, anyone can vibe code. The differentiation will come from the stuff you are NOT vibe coding.”
3. “The highest ROI investment I’ve made in life is paying $20 for ChatGPT or Claude” - Worth more than 30 Netflix subscriptions in utility.
Where Vibe Coding Fails
1. Failure axes: “Large” and “not easy for software to do” - Complexity increases failure rates.
2. Local LLMs (Ollama, etc.): “Possible but not as fast or capable. Useful offline, but doesn’t match online experience yet.”
Final Takeaways
1. “Practice vibe coding every day for one month” - Habit formation requires forced daily practice.
2. “Learn to give up” - When something fails repeatedly, start fresh rather than debugging endlessly.
3. “Share what you vibe coded” - Teaching others cements your own learning. “We learn best when we teach.”
4. Tool knowledge is temporary: “This field moves so fast, by the time somebody comes up with a MOOC, it’s outdated.”

Sat, 22 Nov 2025 00:00:00 +0000

Nano Banano Pro has excellent text generation (though it doesn’t always give you what you want in the first try).

I couldn’t spot any errors in the generated text. Can you?

I used this prompt (with the workshop details and my photo): Create a professional poster for the below, including all relevant information. Use my photo (attached) professionally.

The NPTEL workshop is real, BTW. First 100 seats, I think. You can register here: https://elearn.nptel.ac.in/shop/iit-workshops/ongoing/computer-science/applied-vibe-coding-workshop/

Things I Learned - 26 Oct 2025

Sun, 26 Oct 2025 00:00:00 +0000

This week, I learned:

Before founding a place to do good, work in a place that does good and learn. Ben Werdmuller
What should we teach when vibe coding becomes good enough for non-coders? Ethan Mollick
- Problem decomposition
- Clear communication & spec writing
- Core technical foundations: file systems, access control, networking, APIs, version control, data structures, databases, deployment
- Software development skills: Debugging, Testing, Refactoring, Design patterns, UI/UX
- Project management: requirements, prioritization, scoping, …
Codex CLI tips:
- codex --add-dir $DIR lets you write into $DIR
- codex --full-auto is the equivalent of codex --sandbox workspace-write --ask-for-approval on-request
Terse code is not necessarily easier or harder for LLMs to write. It’s about how unusual (or not aligned with training data) the code is. Gabi Teoduru
How are people using browser agents like Comet / Atlas? Simon Willison
- Most popular: YouTube video summaries with timestamps
- Most useful: Form filling: Government forms, data entry, repetitive bureaucratic tasks
  - Foreign language navigation: Applying for pension in Korea, navigating sites in other languages
  - Time reporting auto-completion
  - Insurance claims: Reading policy documents and drafting appeals (successfully got claim reimbursed in India)
  - Compliance training click throughs
- Next most useful: Shopping / planning
  - Energy provider comparison - Comet checked current plan vs competitors on Check24, calculated exact annual savings per provider
  - Financial tracking: Finding Amazon orders, tracking Airbnb spending with refund calculations, analyzing bank transactions
  - Trip planning: Mapping 50-100 places on Google Maps automatically
- Interesting: Airport shuttle discovery - Found shuttle that user missed in manual searching
HubFS mounts GitHub repos on the file system. Every file system action directly works on GitHub via a REST API. Useful for some scenarios but less useful for note-taking than something like GitDoc which offers a delayed sync.
Ernest Ryu solved an open problem in convex optimization using ChatGPT. Quotes:
- ChatGPT is now at the level of solving some math research questions, but you do need an expert guiding it.
- ChatGPT was really effective at accelerating my progress. This work took about 12 hours, spread over 3 days. In hindsight, the proof is really simple.
- But I iterated through so many other strategies that didn’t pan out, and ChatGPT crucially helped to quickly explore and eliminate those dead-end approaches. Also, the key successful steps were suggested by ChatGPT.
- ChatGPT did not produce the proof in a single prompt. The process was highly interactive. It generated many arguments, roughly 80% of which were incorrect.
- Yet some were genuinely novel to me. Whenever I recognized a novel idea, whether correct or only partially so, I distilled the key insight and prompted ChatGPT to develop it further.
- My contribution:
  - Filtering out incorrect arguments and accumulating a set of correct facts.
  - Identifying promising new lines of reasoning and guiding ChatGPT to explore them further
  - Recognizing when a strategy had been fully explored and deciding when to move on.
- ChatGPT’s contribution:
  - Producing the final proof argument.
  - Significantly accelerating my (or our) exploration of the many dead-end arguments, rapidly ruling out approaches that did not work.
Comparing the GPT 4.1 and 5 models at all different of reasoning, I’ve switched my default from GPT 4.1 mini to GPT 5 mini (medium). Far smarter for a slightly higher cost. Artificial Analysis
python -m pdb -c continue script.py or uv run -m pdb -c continue script.py runs a script and drops into pdb on unhandled exceptions (post-mortem). ChatGPT
Technology removes constraints. We then do what we really value. Claude
- When writing became digitized, we stopped cared about spelling/handwriting for its own sake. Spelling bees and handwriting classes declined. “ur” is acceptable.
- When fitness tracking became easy, many just track, few exercise more. Few people value exercise
- When GPS became ubiquitous, we stopped learning geography. Most value arriving, not knowing
- When photography became unlimited, most captured moments. Few perfected shots
I had Codex scrape my ~2,000 pending invites on LinkedIn and asked ChatGPT to analyze it. Here are learnings: ChatGPT, private
- Power-law. 5% of inviters account for ~42% of all common connections. Top 10 people alone for ~20%.
- IITM student invites are high (~14%), but with 0-2 common connects, i.e. distant strangers.
- EdTech is tiny in count but has the highest common connections per person (outlier-sensitive but real).
- Among ≥20-commons, many hold VP/Head/Site-Lead titles in Data/AI or GenAI (not just recruiters).
- GenAI people are 7-8% and steady across months. Not a useful signal to prioritize.
- Premium ~ Senior. Premium accounts show ~40% senior titles vs ~29% for non-premium.
- Finance invites have higher seniority rate and more common connects than healthcare.
- Followers have higher common connections (~6 vs ~4).
⭐ Memory can be code. Agent memory is anything it choose to persist. Agents can write code on the fly to automate tasks, save them, and serve the code on the next request, potentially modifying the code as required. This is like the conscious mind saving a habit for the subconscious to execute fast.
Finally: Microsoft Office has an agent mode that lets you talk to it and do stuff. The Verge

Vibe-Coding for Interesting Data Stories

Mon, 06 Oct 2025 09:03:35 +0000

Last weekend, I fed Codex my browser history and said “explore.” It found a pattern I call rabbit holes – three ways we browse:

Linear spiral - one page > next page > next. E.g. filing income tax, clicking “next” on the PyCon schedule.
Hub & spoke - hub > open tabs > back to hub. E.g. exploring DHH’s Ubuntu setup, checking Firebase config.
Wide survey - source > many, many pages. E.g. clearing inbox, scanning news.

Then Claude Code built this lovely data story.

My goal? Find challenges in vibe-coding interesting data stories. I found several.

A. I don’t know what I want.

Solution? Ask for multiple options. More options = more ideas. Codex proposed two I hadn’t planned: rabbit holes and search funnels.

B. I don’t know if it’ll turn out well.

Solution? Build them all. Don’t pre-judge. I did not expect rabbit holes to be interesting - a clear prediction error.

C. Reviewing is the bottleneck. It’s slow and painful.

Solution? Make reviews easy.

Ask for review-friendly output. E.g. A table/heatmap comparing options.
Use LLMs to pre-review. E.g. Pick top 3 with reasons.
Review output, not code. E.g. Have it build a working demo, then review.

D. Model / tool strengths vary.

Solution? Align with strengths. For example:

Use GPT-5 for planning. It’s better than GPT-5-Codex or Claude 4.5 Sonnet.
Code UI with Claude 4.5 Sonnet. It’s better than most models.

Check out the prompts & process.

Try this: Pick one messy dataset you have. Ask an LLM for five ways to explore it. Build them all. One will surprise you.

Fri, 12 Sep 2025 00:00:00 +0000

Slides for my DataHack Summit talk (controversially) titled RIP Data Scientists are at https://sanand0.github.io/talks/2025-08-21-rip-data-scientists/

Summary: as data scientists we explore, clean, model, explain, deploy, and anonymize datasets. I live-vibe-coded each step with DGCA data in 35 minutes using ChatGPT.

Of course, it’s the tasks that are dying, not the role. Data scientists will leverage AI, differentiate on other skills, and move on.

But the highlight was an audience comment: “I’m no data scientist. I’m a domain person. I’ll tell you all this: If you don’t follow these practices, you won’t have a job with me!”

They’re catching on! 🙂

Things I Learned - 17 Aug 2025

Sun, 17 Aug 2025 00:00:00 +0000

This week, I learned:

Git partial clone lets you fetch files on-demand! E.g. git clone --filter='blobs:size=100k' <repo> will clone files under 100K and fetch the rest only on checkout. Over time, Git LFS capabilities will migrate into native Git. Ref
⭐ From Daniel Kahneman, The Knowledge Project Podcast.
- Key lesson. Have lower expectations. Behavior change is hard.
- Happiness is pleasure in the moment. Satisfaction is the meaningful story of our life. When reflecting, the thinking brain wants satisfaction. When feeling, the feeling brain feels happiness. The 2 brains optimize for different things. The thinking brain packs the calendar with satisfying tasks that the feeling brain hates doing.
- Happiness & pleasure are both are good for us. We don’t know which matters more.
- Behavior change is harder than most people think. Usually, it’s better not to expect success. Changing others, or ourselves.
  - Instead, understand the cause of that behavior. Behaviour is an equilibrium of forces.
  - Weakening forces preventing right behaviour is easier than strengthening forward forces. It lowers tension. That’s inversion!
  - Behaviours are more about situations than personality. We assume otherwise - that’s an attribution error.
  - Environment shapes thinking but it’s not obvious how, e.g. some people work better in noisy cafes. Some colors are more calming.
- Leadership & delegation
  - Motivation is complex. People can do bad things for good reasons and vice versa.
  - So, delegate decisions to unemotional agents. But agents misjudge perceived value of gain or loss!
  - People prefer over-confident intuitive leaders over slow, deliberate leaders.
  - Protect dissenters and dissent. It’s painful and costly, and needs nurturing.
- Negotiation is about understanding, not convincing.
- “Feelings get in the way of clear thinking.”
  - Example: I vibe-coded the last 2 questions of TDS GA7 on Claude Code. It didn’t run. I delayed fixing it for 5 days, afraid it would a major effort. It ended up a 2 min fix. It could have been major, but checking would have helped. Fear prevented that.
  - Intuition, emotion, beliefs hamper clear thinking. Beliefs are often formed based on people we admire or identify, not reason.
- What enables clear thinking (all are hard):
  - Pragmatism. Don’t threaten your identity, the leader, etc. Else none of this works.
  - Rules, systems and processes. Willpower is illusion. Alignment is an illusion. “Whereever there is judgement, there is noise, and more than what people think.”
  - Standards. Shared, consistent scales of evaluation. Super-forecasters use probability scales.
  - Deliberation. Slow decision making.
  - Decomposition. Break down the problem, analyze it, THEN form an intuition. Be disciplined in delaying intuition or forming an opinion.
  - Pre-mortems. “Write the history of the disaster this decision led to.”
  - Decision journals with post-mortems. Pros, cons and alternatives from failed decisions, e.g. Ray Dalio’s principles. Change of mind.
  - Independent data. Use data. Keep evidence gatherers independent of decision makers.
  - Preparation. Have decision makers write down decisions before discussing. Increases diversity.
DuckDB’s feature engineering capabilites are faster than scikit-learn. DuckDB
Developers are encoding their entire SDLC workflow into Claude commands ChatGPT #ai-coding
- Commands are used for:
  - Requirements: Research sub-agent, task breakdown into todos.md, creating specs.md from todos.md
  - Progress tracking: session logging, effort tracking, updating status, planning next steps
  - Project setup: initializing, adding deps, scaffolding features
  - Development: code review, debug error (five whys), explain code, refactor code
  - Optimization: optimize build, DB, caching
  - Testing: TDD, generate test cases, set up unit/integration/E2E testing, analyze coverage
  - Security: security audits, dependency vulnerability scans
  - Integration: sync tasks between GitHub and Linear (two-way issue synchronization, PR linking)
  - Deployment: prepare releases, hotfix deploys, rollbacks, containerization, CI pipeline setup
- Patterns of usage
  - Sub-agents
  - Command handoffs, i.e. one command invoking another
  - Shared among a team in a repo, enforcing standards & sharing best practices
  - Integration with specific tools / APIs (e.g. Linear)
⭐ LLMs can hyper-personalize demos. E.g. an LLM document generator demo accepts a role, document type, and prompt. The demo-er says “Bank, LinkedIn marketing” and the LLM auto-populates the fields aptly, re-purposing the demo.
From the GPT 5 coding cheatsheet:
1. Be precise and avoid conflicting information. Use a prompt optimizer to check for inconsistencies.
2. Use the right reasoning effort. Prefer medium or low reasoning to avoid overthinking simple problems.
3. Use XML-like syntax to help structure instructions
4. Avoid overly firm language, e.g. “You MUST be THOROUGH” vs “Thoroughly”.
5. Give room for planning and self-reflection. Explain what to do in steps, asking it to think deeply
6. Control the eagerness of your coding agent, e.g. do not ask for confirmation, parallelize tool calls, use more tools, etc.
⭐ Assets are any leveragable stored capability. Money is one, but there are several one can “invest” in, be an agent of, or perhaps steal.
1. Wealth (investments, income)
2. Regenerative assets (land, carbon credits, renewables)
3. Contacts (reference customers, hiring pipeline, talent bench, weak-ties)
4. Distribution channels (repeatable routes to users: partnerships, marketplaces, APIs, SEO)
5. Attention (your audience, whom you can reach directly)
6. Trust/reputation in communities (community capital in employers, clients, forums, society, search keywords)
7. Personal brand “edges” (moral authority, values lived aloud, distinctive taste or stance)
8. Data (your clean, labeled, joined data corpus)
9. Code (models, algorithms, components, templates, libraries, tools, evals; versioned)
10. Content (blog posts, video tutorials, case studies, demos, stories, slides, docs)
11. Knowledge (notes, decision logs, knowledge graph, institutional memory)
12. Playbooks & runbooks (process checklists that survived fire, SOPs, scenario plans)
13. Habits & policies (operating cadence, rituals, governance & compliance muscle)
14. Optionality (cash buffer, credit lines, slack time, real options, small bets)
15. Agreements (MSAs/SLAs, pre-negotiated contracts)
16. IP (copyrights, trade secrets, trademarks)
17. Health & energy reserves
⭐ Intense negative emotions get in the way of clear thinking. Curiosity, humor, kindness, and gratitude help. (Intense positive emotions like awe, passion, etc. help creativity and are not so bad.) #beliefs
I like to think I’m a Python expert. When I saw a client use this code, I told her the indentation is wrong. It ran just fine. And people think only LLMs hallucinate.
This is undocumented, but the way to get an Gemini ephemeral auth token for the live API is below. (Update time as required.) ChatGPT
Learnings from a discussion on vibe-coding between Kunal Jain, Ravi Nadimpalli and me. #ai-coding
- On the Vibe Coding Process & Strategy
  - The 80/20 Rule is Real: The first 80% of a project is incredibly fast, but the final 20% (debugging, custom features, production-readiness) is extremely difficult and time-consuming.
  - Validation is the New Bottleneck: Since coding is now much faster, the critical, time-consuming task has shifted to reviewing, testing, and validating the LLM’s output.
  - “Spec-Locking” is Crucial: Providing the LLM with detailed, well-defined, and “thinly sliced” specifications is essential for getting good results. Vague requests lead to poor outcomes.
  - It’s Not Production-Ready (Yet): The consensus is that vibe coding is excellent for prototypes, demos, and go-to-market (GTM) activities but is not yet reliable for building production-grade applications from scratch.
  - Code is Brittle & Unstable: An application that works perfectly one day can inexplicably break the next, as the underlying agent might make undocumented changes.
- Impact on Roles & The Future of Work
  - The Rise of QC/Validation: The Quality Control (QC) function will become larger and more critical to manage the new challenge of validating AI-generated work.
  - Product Managers Shift Focus: PMs can move away from tedious documentation (like flowcharts) and focus more on high-level business strategy, using vibe coding to create quick prototypes.
  - Democratization of Building: It empowers non-coders to build functional apps and helps professionals upskill faster by “conversing” with an LLM on complex topics.
  - New Forms of Cheating: The technology is creating novel ways for people to cheat in interviews, such as using tools that provide real-time subtitles of answers.
  - The “Jagged Edge” of AI: The technology excels at certain tasks (like GTM content) but fails at others, creating new upstream bottlenecks where teams must rapidly generate more of the “AI-friendly” work.
- Practical Hacks & Takeaways
  - Meta-Prompting: Use an LLM to refine and improve your prompt before giving it to the final tool. This helps fill in gaps and add necessary detail.
  - Human-First Drafting: For creative or nuanced work (like writing), it’s often better to write the first draft yourself and use the LLM to polish it, rather than starting with a generic AI draft.
  - Use Structured Prompts: For predictable and clean output, providing instructions in a structured format (JSON is OK but not needed) is highly effective.
  - LLM as a Judge: Use LLMs to evaluate and grade content, code, and other outputs, dramatically speeding up the review process.
  - Automate Learning & Documentation: Use tools to transcribe conversations automatically and create personalized revision quizzes from notes and documents.
  - Voice is a Powerful Modality: Using voice-to-code allows for capturing more complex ideas faster and can be done while multitasking (e.g., walking), capitalizing on “dead time.”
For live transcription, Gemini 2.5 Flash Live costs 0.6c/min of audio ($3/MTok x 32 tokens/second) while GPT 4o Mini Realtime costs ~2c/min and GPT 4o Realtime costs ~8c/min. ChatGPT
I set up MCPs Codex CLI by adding this to ~/.codex/config.toml. I’ve disabled it for faster startup (this takes ~2 seconds) and raised an enhancement issue for MCP lazy loading
Anthropic launched a remote MCP connector in their API. OpenAI Responses API already had remote MCP support. Gemini will likely follow, opening up new tool capabilities. The APIs can directly call the MCPs as part of their thinking.
Turns out Indian English is a well studied topic. Indianisms like “can able to”, “need not to”, “why because…”, “if suppose…”, “return back”, “revert back”, “angry on”, “discuss about”, “order for”, “do one thing…”, “give me a missed call”, “what is your good name”, “kindly adjust”, “we are like that only”, “he is coming only”, “today itself”, “now only”, “prepone”, “pass out (of college)”, “out of station”, “do the needful”, “hotel”, “batchmate”, “cousin-brother / cousin-sister”, “I have a doubt”, “I am understanding”, “she is knowing”, “you’re coming, no?” etc. are discussed in Pingali Sailaja’s Indian English. ChatGPT
Astral is building pyx - a paid PyPi alternative. It aims to solve problems like PyTorch CUDA builds. Knowing them, it’ll be fabulous. I look forward to when they build a Python hosting service.
⭐ Here’s one way to improve LLMs apps in real-time.
- After sending a response, send the prompt + input + output + optional user feedback to an LLM-as-a-judge asking for feedback to improve the prompt.
- Revise the prompt based on the improvement. Now the app has improved, real-time, based on human/LLM feedback.
- Refine this process to ensure that the revisions are smooth and positive.
GPT 4.1 (and presumably GPT 5) models have been trained on a specific diff format useful for code diff-patching. PseudoPatch is a Python package that implements their apply_patch() function. Aider supports multiple edit formats that are commonly referenced as a standard. Code Surgery has a good walkthrough of various strategies. These are similar to Google’s diff-match-patch approach (which fuzzy matches and then patches) but does not require line numbers. ChatGPT
Here are some query parameters ChatGPT.com unofficially supports:
- ?q=... prefills in a new chat and often auto-submits, especially small text #. Useful for:
  - A custom search engine in your browser
  - An “Ask ChatGPT about selection” bookmarklet, etc.
  - Links (e.g. from courses, FAQs, etc.) for tasks or learning
  - … but not for custom GPTs
- ?model=... selects a model (e.g., gpt-5-thinking).
- ?hints=search enables Search mode
- ?temporary-chat=true opens a new temporary chat
Tavus is another AI avatar platform.
- Synthesia. Market leader; $2.1B valuation; enterprise trusted. Good: Realism, enterprise features, templating. But: Price, usage caps, slower avatar setup
- HeyGen. Rapidly growing; $500M valuation. Good: Avatar realism, speed, affordability. But: Basic collaboration, support, scene complexity
- Colossyan. Favored L&D focus. Good: Interactive & educational tools, good value. But: Less polished avatars, slower renders
- D-ID. Frequently cited alternative. Good: Speed, flexibility, custom avatars. But: Watermarks, fewer templates
- Elai.io. Repeats in alternatives lists. Good: Storyboarding, educational formats. But: Limited templates, render time
- Hour One. Also common in alternative lists. Good: Photoreal avatars, expression control. But: Missing advanced features like screen capture
- Others. Niche or emerging tools. Good: Varies by platform. But: Less adoption, fewer reviews
Training companies are offering “Labs-as-a-service” as part of their AI training. Corporates ban LLMs, but need employees trained. Trainers offer a bundled package where they also offer access to LLMs are part of their course. Interesting business-model value-add.
⭐ I’m meta-AI-coding. I wrote a crude prompt in prompts.md, told Codex “prompts.md has a prompt under the “# Improve schema” section starting line 294. This is a prompt that will be passed to Claude Code to implement. Ask me questions as required and improve the prompt so that the results will be in line with my expectations, one-shot.” After a few discussions, it generated this remarkable prompt. This prompt was easy for me to review AND easy for Claude Code to understand because of the lack of inconsistencies.
- Use the Ask-Code pattern. In Codex, speak the requirement and have it rewrite the prompt asking clarifying questions pressing the Ask button instead of Code. Then, answer its questions. Then press Code.
A Forward Deployed Engineer (FDE) is a hybrid role, part software engineer, part product manager, and part consultant, focused on deeply integrating a company’s technology with a specific client’s needs.
Based on what I’ve seen of AI coding, new developers need to learn these skills. #ai-coding
- Context engineering
- Documentation
- Automated testing
- Standards
- Capabilities of platforms
- Modularity (and DRY vs WET)
- Code composition
- Code reviews
Blindspots continue to be the insight with maximum RoI. Discovering something we’re not even aware we’re unaware of opens up the largest possibilities. #beliefs My top sources to discover blindspots are:
- Feedback. Especially feedback we reject, ignore, or miss.
- Things we run/shy away from.
Across clients, providers (e.g. Bedrock) and products (e.g. Cursor) I have observed capacity bottlenecks for Claude models which don’t seem to affect OpenAI models as much.
Increasing the size of an image improves OCR accuracy for LLM models (or at least Claude 4 Sonnet). Anecdotally, resizing 2x did not work on a number of examples but 2.5x - 3x did. This increases the cost to 6.25x or 9x, however.
Discussion at PyConSG Edu Summit 2025. Padlet
- Discussion validation
- Interesting ways students use AI
  - Use AI to refactor/debug whole codebases
  - Get AI to create questions for practice
  - ChatGPT Study mode
  - Students like to upload photos. We can teach them to upload these to ChatGPT and ask questions.
- What teaching practices / assessment design can help students think for themselves before turning to AI? ChatGPT
  - Interactive orals / micro-vivas (short, process-focused). Strong alignment with “interactive oral assessment” research and guidance in the AI era: improves authenticity, reduces outsourcing/contract cheating, and checks understanding. Make them low-stakes but frequent. How: 5–8 min viva tied to a task; students must explain choices, failures, and next steps.
  - Authentic / project-based assessments students can self-validate (observable outputs). Project-based and “authentic” assessment meta-reviews show consistent positive effects (achievement, thinking skills, motivation), especially in STEM and small teams. Design tasks with local data/constraints so generic LLM answers are only a baseline. How: “Default AI answer” gets a pass; “A-grade” requires empirical validation, custom data, or optimisation trade-offs with metrics.
  - Pair programming + peer critique on whiteboards/pseudocode. Evidence (meta-analyses & CS-ed studies) supports pair programming for learning and retention; code tracing/peer instruction deepen understanding before coding. How: Rotate driver/navigator; force commit-message style rationales; 10-minute “whiteboard dry-run” before touching IDE.
  - Process-over-product with structured reflection. Metacognitive/reflective interventions show medium-to-large effects on achievement; they also build habits that resist blind acceptance of AI outputs. Keep reflections short but structured. How: “What I asked AI; what it missed; how I verified; what I’d change next time.”
  - “No-AI under secure conditions” mixed with AI-permitted coursework. Matches national/institutional guidance for GenAI-aware assessment design. Use secure, time-boxed checks for fundamentals; allow AI elsewhere with audit trails.
  - Primary research (interviews/user studies) before design/coding. Fits the “authentic assessment” literature and reduces LLM substitution. Grade on research protocol + synthesis rigor, not word count.
  - Explicit problem-solving frames (initial/current/goal state). Classic problem-solving scaffolds; improves formulation before querying AI. Pair with short “assumption logs.” (General pedagogy supported; CT depends on domain knowledge – see caveat below.)
  - Caveat (important): Critical thinking depends on domain knowledge. Don’t expect generic CT drills to transfer without content mastery. Plan tasks so students must recall/apply specific knowledge before or alongside AI.
- How can we train students to use AI critically instead of accepting the output blindly? ChatGPT
  - Teach “lateral reading” and SIFT for source checking. Stanford’s Civic Online Reasoning work and Caulfield’s SIFT method offer actionable heuristics for verifying claims, URLs, and citations that LLMs surface. Build these into rubrics.
  - Run “AI auditing” labs (hallucination hunts). Students collect/label model mistakes, missing assumptions, and fabricated citations – an approach aligned with UNESCO’s call for AI literacy and validation.
  - Use online judges with hidden tests + adversarial cases. Autograding literature supports hidden tests for robust generalization; it trains students to verify and not overfit to visible specs – or to AI’s surface patterns.
  - “Sandwich” workflow: spec → implement 1–2 reps → let AI complete → verify rigorously. Mirrors human-in-the-loop patterns in industry; use checklists for unit/property tests and invariants before accepting AI output.
  - Live-coding with an AI assistant on display (to show failure modes). Demonstrates nondeterminism/limitations in real time; supports critical habits. Pair with a post-mortem template.
  - Prompt red-teaming/jailbreak exercises (safe scope). Students learn that guardrails can be bypassed and why verification matters. Keep it ethical and bounded.
  - Build a knowledge base first. Reinforce that CT sits on content knowledge; teach students to explain why an AI answer is plausible or not, citing domain facts.
Notes from “My Thoughts on Computational Thinking in the Generative AI Era” by LEONG Hon Wai, ex-NUS, at PyConSG Edu Summit 2025
- Students from China don’t like to write, express their ideas, and share. That’s changing now.
- Computational thinking is pretty new (Jeannette Wing, 2006), actually, based on Papert (1980). It’s too early to abandon it.
- It enables effective learning attitudes:
  - Tinker (experiment & play): helps finding diverse problems to generalize into
  - Debug (find & fix bugs)
  - Create (design & make)
  - Persevere (keep going): but only if it’s productive, i.e failing in new ways
  - Collaborate & communicate
- Teaching this is hard. Get students to WANT to do computational thinking.
- Problem formulation (among the computational thinking blocks) is more important than before.
- Leveraging Computational Thinking in the Era of Generative AI argues that computational thinking manifests in prompt/context engineering.
- We’re moving from “Computational Thinking” to “Computational Action” – where we’re talking to AI coders that actually deploy apps that DO stuff.
Notes from “Make Learning Easy and Fun @ NLB LearnX” by Goh Soon Seng, NLB, at PyConSG Edu Summit 2025
- Libraries have a Pi Python Makers Club, open for all. Bi-monthly meetings. Quarterly Pi Python workshop.
- Space provides 3D printers, Raspberry Pi, sensors, etc.
Notes from “Teaching Goals and Plans - How we might help students improve problem-solving” by Dr Norman Lee, SUTD, at PyConSG Edu Summit 2025
- Programming is hard. E.g. Solving the Rainfall problem “Sum numbers until 99999” needs several building blocks:
  - Python syntax
  - Getting user input
  - While loop
  - Controlling while loop with counter
  - Accumulation
  - If-else
- Merging (or composing) such blocks is the hard part. In Learning to program = learning to construct mechanisms and explanations, Soloway, shares 4 compositions.
  - Abutment: Put one block after another
  - Nesting: Put one block inside another
  - Merging: Interleave the code in the blocks
  - Tailoring: Modify the code in the blocks
- But you need to already have those primitives (patterns) to put together. The “expert blind spot” blinds experts to this.
- Actionable ideas:
  1. Teach patterns explicitly
  2. Create exercises on applying them
  3. Use Parsons problems: Fill in the blanks. Re-order lines of code. But design problem carefully
  4. Step through a debugger. BUT students must predict next line, not passive watching
  5. Teach to from one format (psuedocode, flowchart, another language like Excel) to Python. Helps multiple modes of learning
Notes from “AISG programmes” by Chen Qeiquang, AI Singapore, AI Apprentice Programme (AIAP) Assistant Head
- Full-time. For SG citizens. $4,000/month. Build 3-6 month MVPs for startups, SMEs, or corporates. 300/1000 delivered so far.
- No lectures/tutorials. Focus is: topic assignments, discussion with mentors, apprentice sharing sessions.
- Includes an LLM Application Developer Program.
Notes from “Scaffolding the Problem-Solving Process for Introductory Computing Students” by Ashish Dandekar, NUS, at PyConSG Edu Summit 2025
- Built an intelligent tutoring system
- Encourage students to create their own pattern banks / cheat sheets. “Find 2 more problems that can be solved in the same way.”
- Focusing on the problem-solving process shrinks the gap. Students above the 50th percentile of pre-assessment did not improve much. The lowest percentile improved the most.
- “At NUS, I know that even if I give 0.5% weightage for students attending tutorials, everyone will attend it for those ‘free marks’.”
Notes from “Exploring Multi-Agent Generative AI in Education and Career Advisory” by Dr Yeo Wee Kiang, NUS, at PyConSG Edu Summit 2025
- ⭐ “When you have a high fever, do you speak more sense or nonsense? Nonsense. LLM temperature is like that. But it can also sound creative!”
- The router pattern is a powerful query rewriter. Redirects the query to specialized prompts/agents.
- Useful tools you can build for students: Course Mentor, Interview Coach, Job planner/matcher.
Notes from “Do we need to teach coding given vibe-coding tools?” by Dr. Oka Kurniawan, SUTD, at PyConSG Edu Summit 2025
- Paper: What the Science of Learning Teaches Us About Arithmetic Fluency says mental math helps mathematicians. Fluency bootstraps higher-level thinking.
- MIT Media Lab’s Project: Your Brain on ChatGPT. Explores impact on brain. Bran-only group had the widest ranging brain networks. AI accumulates cognitive debt.
- Paper: “A Study of the Difficulties of Novice Programmers” struggle with:
  1. Syntax
  2. Problem solving
  3. Tools
  4. Computing concepts
  5. Analytical thinking / debugging
- Polya’s How to Solve It is the base problem solving framework for maths and can be adapted to computing
- Expert programmers have enough patterns to match against. Novices don’t. We need a bottoms-up framework instead
  - Give them a concrete case.
  - Have them generalize (loops, functional, vectors)
  - Have them implement (debugging)
  - Have them break it (test)
  - All via vibe-coding!
  - The chats are tracked!!
- Paper: First Things First: Providing Metacognitive Scaffolding for Interpreting Problem Prompts
  - Students often get the problem wrong
  - Reading student conversations helps figure it out
  - LLMs can figure it out too!
- Paper: The Widening Gap: The Benefits and Harms of Generative AI for Novice Programmers
  - Good coders got better with AI. Were able to ignore unhelpful advice.
  - Poor coders got worse! Thought they performed better than they did. Increased illusion of competence.
The Bebras Challenge is a global non-programming computational thinking (CT) challenge. Examples. Singapore runs a National Junior Informatics Olympiad that learns from Bebras. It tests the mindset behind coding, specifically “computational thinking”:
- Problem formulation (added recently, and is increasingly important)
- Decomposition (and composition): break the problem down
- Pattern recognition: find the building blocks
- Abstraction: generalize useful blocks, drop irrelevant ones
- Algorithmic thinking: write the steps to solve
- Validation (not part of original list, but critical): how to efficiently check if this works
Apple’s Embedding Atlas (Demo - slow, needs WebGPU) is an embeddings visualizer, like Tensorflow Projector or Mantis (Demo).
John Kotter’s organizational change model is the accepted practice for top-down change, while ADKAR is for bottom up. It’s surprising how obviously effective both are to someone who has effected both kinds of changes, but there is NO WAY I would have appreciated either during my MBA. Wikipedia: Change management
The OpenAI Chat Completions API has a few interesting and (relatively) new options:
- verbosity. low: concise response, medium: default, high: verbose
- reasoning_effort: minimal: almost none. medium: default. Or low, high.
- truncation: auto: truncate response by dropping input items in the middle. disabled: default
- prediction: speeds up output for minor corrections to text
- prompt_cache_key: tailors per-user caches
CSS nesting can be used with media queries too! Julia Evans
id3v2, mid3v2 and eyeD3 seem the cleanest way of editing MP3 tags on the CLI. mid3v2 was already installed on my system.
Learnings people shared in Ask HN: What trick of the trade took you too long to learn?
- Finance & housing
  - Time is a non-renewable asset.
  - Lifestyle design matters as much as net worth.
  - Future-proof against regret. The present matters, too.
  - Home ownership ties up location choice, capital and has hidden costs.
  - Market timing & geographic arbitrage has an outsized effect.
- Software
  - Align abstraction to domain. Avoid premature abstraction (Don’t Repeat Yourself vs Write Everything Twice) and over-abstraction.
  - Temporary fixes tend to stick. Stop-gap regexes last for years.
  - Consistency is a quality multiplier. Small inconsistencies cause disproportionate harm.
  - git bisect is a regression-finding superpower.
  - It’s OK to write tests covering key parts of legacy codebases - 100% coverage isn’t critical.
  - Document architectural decisions: why this approach. See Diátaxis.
  - Flow metrics predict delivery better than (arbitrary) estimates.
  - Building features without linking to delivery spesd wastes resources.
- Life habits & learning
  - You have the right to say “no”.
  - Small, consistent actions beat dramatic changes. Persistence beats skill.
  - You’re allowed to change your mind.
  - Over-cleverness backfires. Witty code & communication lead to confusion.
  - Context is king. Without background, everything is mis-interpretable.
  - Fun leads to excellence. Excellence leads to fun.
- The meta-lesson here is how I discovered these:
  - Run topicmodel to identify topics
  - Feed the output CSV to ChatGPT and ask it to share lessons topic-by-by-topic #
Topic modeling can be extended in many ways. #
- Structural Topic Models factor in metadata, like year (numeric) or category or author (categorical).
- Relational Topic Models factor in undirected graph relationships, e.g. parent documents
- Graph-Regularized Topic Models factors in arbitrary graph relationships, e.g. weighted, directed
- Neural (GNN + Topic Model) approaches work better for large graphs, long-range dependencies, etc.
Some ways to inject graph structure into topic similarities to, for example, cluster threaded discussions. #
- Start with a graph similarity matrix S, like #
  - a regularized graph Laplacian (based on degree - adjacency matrix)
  - a similarity matrix like graph2vec from Graph Kernel
  - a node-embedding karateclub.
- Option 1: “Smoothen” the embedding matrix multiplying it with S (i.e. spread each document towards neighbors), then calculate similarities
- Option 2: Take the weighted average of S and the embedding similarity matrix
You can extract Hacker News comments as a threaded discussion pasting this into the DevTools console:

Vibe-coding is for unproduced, not production, code

Sat, 02 Aug 2025 06:26:18 +0000

Yesterday, I helped two people vibe-code solutions. Both were non-expert IT pros who can code but aren’t fluent.

Person Alpha and I were on a call in the morning. Alpha needed to OCR PDF pages. I bragged, “Ten minutes. Let’s do it now!” But I was on a train with only my phone, so Alpha had to code. Vibe-coding was the only option.

Me: Go to any chat engine and pick Claude Sonnet 4 as your model.
Alpha: We have an internal chatbot that has Claude Sonnet 4.
Me: Type, “Write a Python program to accept a PDF filename and page number and extract it into output.pdf”.
Alpha: Done. I’m not used to the CLI but can run it in PyCharm.
Me: OK. Run it, but first, modify by saying, “Shorten code. Drop error handling.”
Alpha: Done. (Runs the code, and it works!)
Me: Great. Let’s do the next part. Paste the sample code for OCR from our team into the chatbot.
Alpha: But our chatbot is limited to ~15K characters.
Me: OK. Go to Claude.ai and paste the code.
Alpha: Um… is that allowed? (Alpha’s colleague pitched in, saying “If it weren’t, it’ll be blocked. Also, the code isn’t sensitive, only data, so go ahead.”)
Me: Use this prompt: “Write a Python program to send output.pdf to an LLM for OCR. Use this code as reference.” Then “Shorten code. Drop error handling.”
Alpha: (Runs the code, and it works!)

All this happened during my commute plus a haloumi-cheese-wrap purchase. A very satisfying experience!

That evening, Person Gamma and I were on a call. Gamma had a client meeting and needed an LLM image editing tool tailored. I tried the same approach.

Me: Create a GitHub account, first.
Gamma: I think I already have one. Let me log in.
Me: I’ve given you maintainer access to the repo. You’ll get an email. Accept it. Then upload the images you want edited.
Gamma: Done (with me guiding on what to click)
Me: Now log into https://jules.google.com/
Gamma: Done
Me: In Jules, select the repo and tell it what change you want.
Gamma: OK. “Use the JPG images uploaded as the samples”.
(Jules churns out it’s thinking)
“Oh, wow! This is amazing! It’s actually thinking about the approach.”
(Jules is done in about 2 min)
“My god! This is going to make things so much easier!”
Me: Now publish the branch, create a pull request on GitHub, and merge.
Gamma: Done (with guidance).
Me: Now try something yourself.
Gamma: OK. “Change the prompts to something more relevant that improves the brand image.” (merges the code, and it works!)

Yet another very satisfying experience. Gamma went on to make another change in my absence. Exactly the point: enable them to work without me.

But isn’t vibe code legacy code? Reducing quality, increasing technical debt?

Yes. Vibe-coding ships debt. But not all code is production code. Vibe coding can accelerate throw-away prototypes.

More importantly, so many ideas sit idle because devs lack time and non-devs lack skills. Vibe coding shrinks that effort. That is what vibe-coding is really for.

Think Excel. Most Excel sheets are messy apps, yet Excel’s made more people productive than any language. In No Silver Bullet, Fred Brooks said:

I believe the single most powerful software-productivity strategy for many organizations today is to equip the computer-naive intellectual workers who are on the firing line with personal computers and good generalized writing, drawing, file, and spreadsheet programs and then to turn them loose. The same strategy, carried out with generalized mathematical and statistical packages and some simple programming capabilities, will also work for hundreds of laboratory scientists.

This is what vibe-coding enables. And more.

How To Control Smarter Intelligences

Tue, 01 Jul 2025 06:37:40 +0000

LLMs are smarter than us in many areas. How do we manage them?

This is not a new problem.

VC partners evaluate deep-tech startups.
Science editors review Nobel laureates.
Managers manage specialist teams.
Judges evaluate expert testimony.
Coaches train Olympic athletes.

… and they manage and evaluate “smarter” outputs in many ways:

Verify. Check against an “answer sheet”.
Checklist. Evaluate against pre-defined criteria.
Sampling. Randomly review a subset.
Gating. Accept low-risk work. Evaluate critical ones.
Benchmark. Compare against others.
Red-team. Probe to expose hidden flaws.
Double-blind review. Mask identity to curb bias.
Reproduce. Re-running gives the same output?
Consensus. Aggregate multiple responses. Wisdom of crowds.
Outcome. Did it work in the real world?

For example:

Vibe coding: Non-programmers might glance at lint checks (Checklist) and see if it works (Outcome).
LLM image designs: Developers might check if a few images look good (Sampling) and check a few marketers (Consensus).
LLM news articles: An journalist might run a Checklist, a Double-blind review with experts, and Verify critical facts (Gating).

You already know many of these. You learnt them in Auditing. Statistics. Law. System controls. Policy analysis. Quality engineering. Clinical epidemiology. Investigative journalism. Design critique.

Worth brushing up skills. They’re more important in the AI era.

Sun, 22 Jun 2025 09:52:29 +0000

I use Codex and Jules to code while I walk. I’ve merged several PRs without careful review. This added technical debt.

This weekend, I spent four hours fixing the AI generated tests and code.

What mistakes did it make?

Inconsistency. It flips between execCommand("copy") and clipboard.writeText(). It wavers on timeouts (50 ms vs 100 ms). It doesn’t always run/fix test cases.

Missed edge cases. I switched <div> to <form>. My earlier code didn’t have a type="button", so clicks reloaded the page. It missed that. It also left scripts as plain <script> instead of <script type="module"> which was required.

Limited experimentation. My failed with a HTTP 404 because the common/ directory wasn’t served. I added console.logs to find this. Also, happy-dom won’t handle multiple exports instead of a single export { … }. I wrote code to verify this. Coding agents didn’t run such experiments.

What can we do about it?

Detailed coding rules. E.g. always run test cases and fix until they pass. Only use ESM. Always import from CDN via JSDelivr. That sort of thing.

100% test coverage. Ideally 100% of code and all usage scenarios.

Log everything. My tests got a HTTP 404 because I was not serving the common/ directory. LLMs couldn’t figure this out because it was not logged. Logging everything helps humans and LLMs debug.

Wait. LLMs and coding agents keep improving. A few months down the line, they’ll run more experiments themselves.

Was AI coding worth the effort? Here, yes. The tools worked. Codex saved me 90% effort. My code quality obsession reduced savings to ~70%. Still huge.

Things I Learned - 22 Jun 2025

Sun, 22 Jun 2025 00:00:00 +0000

This week, I learned:

Never use a toothpick on a tooth with a dental crown. Only use a flosser or water flosser.
CSS attr() is one of the most powerful features in modern CSS. It lets you control CSS via HTML attributes.
Notes from Anthropic’s How we built our multi-agent research system:
- Sub-agents are like humans -> society. The improvement is dramatic.
- “Sub-agents facilitate compression by operating in parallel with their own context windows, exploring different aspects of the question simultaneously before condensing…”
- “Each sub-agent also provides separation of concerns—distinct tools, prompts, and exploration trajectories … (enabling) independent investigations.”
- Using sub-agents spends ~15x more tokens. (That explained ~80% of the improved accuracy!)
- Particularly effective when tasks are independent and parallelizable. This also speeds it up.
- Teach the orchestrator how to delegate: how many sub-agents, what objective + output format + task boundaries (MECE to avoid overlap with other agents) in prompt, what tools.
- Teach the orchestrator how to improve agents: e.g. tools to test and rewrite tool descriptions
- Even if you evaluate a few examples, evals are surprisingly effective.
- Agents are stateful. Errors compound. Allow agents to resume. Prune history gracefully.
- Log everything to debug user-reported failures. Also monitor the kinds of decisions it took to help debug at scale.
The Bitter Lesson likely applies to system prompts. Don’t hard-code stuff. I’m impressed that there is no system prompt in the default pydantic-ai Agent.
The MCPs developers seem to use the most are: filesystem, playwright, github, slack, notion.
Anecdotally, Claude 4 Sonnet seems a better coding model than Claude 4 Opus. Dan Becker, Armin Ronacher #ai-coding
Cursor offers background agents that run in a remote container. #ai-coding
Fabric has a collection of re-usable prompts that you can use via llm-templates-fabric like: cat file.py | llm -t fabric:explain_code Ref
As of Jun 21, Claude 3.5 Sonnet > Claude 3.7 Sonnet > O3 Mini > Human > Gemini 1.5 Pro lead the Vending Bench. Gemini 1.5 Pro also leads my System Prompt Override benchmarks. I’m losing faith in the LM Arena. Perhaps the Gemini models aren’t improving as much as we think.
This is the core of agents (LLMs running tools in a loop): Sketch blog Full script
Notes on AI coding / vibe-coding from multiple sources. #ai-coding
- Sources
- Why AI coding?
  - Reduces mental energy (by creating the first draft). letting you create more.
  - Reduces starting trouble, eases effort.
  - Helps figure out how easy / tough a task really is!!
  - Most code is short-lived or has few users. AI building “throw-away” code is useful.
- Why NOT AI coding?
  - Slows you down if you know the repo well
  - Doesn’t work well on large/complex/niche repos
  - Leads to over-optimism and atrophy
- Tips
  - Use for reversible decisions (2-way doors). Avoid for irreversible ones (1-way doors).
  - Fail early. Try tough bits first.
  - Fail often. Restart instead of fixing.
  - Go concurrent. Trigger multiple tasks. Ask for multiple drafts and options.
  - Give it workflow. Break down the implementation into: 1. Planning. 2. API stubs. 3. Implementation.
  - Give local context. Naming conventions, folder structure, coding style, tools (compile, test, lint), etc.
  - Conserve context. Use sub tasks and sub agents to conserve context.
  - Suggest libraries. Agents prefer writing code than using libraries, by default.
  - Give examples to follow, e.g. Write it like @filename. & -> & but &x -> &x.
  - Give screenshots and logs. These are very effective.
  - Provide goals, not instructions. Saves effort, teaches you new things.
  - Farm out research. Have specialized tools research API docs, etc. and include those in the context.
  - Keep related things together.
  - Have it write a checklist, e.g. saving it temporarily in a file.
  - Have it run code to catch its own errors.
  - Have it write tests, mocks for tests.
  - Have it see and use the app, click, play around, etc. (e.g. via playwright-mcp)
  - Have it create playbooks, examples, troubleshooting guides.
  - Have it refactor code AFTER comprehensive tests.
  - Have it think more. Use ultrathink.
  - Log extensively, by default. Improves future debugging.
  - Report errors well. What happened, why, and what to do.
  - Prefer monorepos for more context. #
  - Prefer popular libraries. LLMs know these better.
  - Prefer fast tests, tools, and libraries. Speed helps iteration.
  - Prefer small files and packages. Reduces context.
  - Prefer simple code. Avoid magic, e.g. pytest fixture injection. Functions over classes. SQL over code. Composition over inheritence.
  - Prefer specialized functions for common scenarios over DRY abstractions. Prefer fewer abstraction layers.
  - Prefer re-implementing over DRY since code is cheap.
  - Look for new tricks to learn from its code.
- Agent behaviors:
  - Simple tasks perform better. More context = more confusion.
  - Verifiable tasks are clearer for LLMs and and easier to review.
  - Useful coding agent tools: bash(cmd), patch(hunks), todo(tasks), web_nav(url), web_eval(script), web_logs(), web_screenshot(), keyword_search(keywords), codereview()
- Skills:
  - LESS Coding
  - LESS Research
  - LESS Documentation
  - LESS Operations configuration (IaaC, CI/CD, etc)
  - LESS Editor usage and expertise required
  - MORE Tests (to test the code)
  - MORE Code reviews (to test the code)
  - MORE Prompting and context creation (to write the code)
  - MORE DevOps (micro-feature deployments, deploy in parallel)
  - MORE Specs: features, requirements, APIs, tests, structure, etc.
  - MORE Analysis: security, performance.
  - MORE Tool design. Linters, SAST, DAST, Performance, etc. Semgrep, Bench Suite
  - MORE Observability: Especially for tools and LLM calls. Telemetry, log analysis and issue creation. Sentry, LogFire, etc.
- Trends:
  - Agents took time to evolve because LLMs need to be good at tool calling and long instruction following, which is just happening.
  - Agents are slow. Parallelizable tools (e.g. multiple Redis instances, container-use, CI/CD) will grow. Tool speed (e.g. fast test engines with caching) will become more important.
  - Agents generate diffs/PRs. Tools to edit and comment on these online will emerge.
  - Context gathering will widen: screenshots, logs, etc.
  - Code review process will be re-invented.
  - Personalized features. User drops a feature request via Slack. Personalized version deployed at their endpoint to test. PR sent after they are happy
  - Poor coding teams get less out of AI coding. Good communication, reviews, coding practices, testing, etc. help.
  - Agent Experience (AX) is emerging and explores: how much context to take, when & how often to ask the user questions, to how make review easier, etc.
  - Humans running multiple tasks in parallel is productive. Breaking a complex requirement into tasks (like Codex now does) helps create that task queue.
  - Agents generate technical debt faster than humans. Solving this will become a major problem/opportunity.
- “makework”: made-up work that fills time or serves short-term needs.
From GPT 4.1 Prompting Guide
- Use more precise prompts. Earlier models inferred user intent. GPT 4.1 follows prompts more closely.
- Avoid STRONG untested instructions. E.g. “you must call a tool before responding to the user” can lead to tool input hallucination.
- For agents, include these three system instructions:
  - You are an agent. Keep going until you’re sure the user’s query is completely resolved.
  - If you are not sure, use your tools: do NOT guess or make up an answer.
  - Plan extensively before each function call. Reflect on the outcomes of the previous function calls. DO NOT do this entire process by making function calls only, as this can impair your ability to solve the problem and think insightfully.
- Use tools field rather than injecting tools into system prompt. Model has been trained to use tools field.
- Keep tool descriptions concise. Provide examples for complex tools in system prompt.
- Place instructions at the top of the context; ideally at the end, too.
- Format prompts as Markdown, XML, not JSON.
- It sometimes dislikes large repetitive output (e.g. analysis of hundreds of items) and needs nudging.
- It handles diffs well and can apply patches
Metaprompting. Have frontier LLMs revise prompts. They’re GOOD! Ref
- Increase clarity, providing step-by-step instructions.
- Resolve conflicting instructions.
- Expand instructions to cover all scenarios and edge cases.
Notes from Pydantic AI GitHub CI:
- UV_PYTHON sets default Python version
- COLUMNS increase terminal width
- uv run supports --extra for extra packages
- cloudflare/wrangler action has a deploy that allows deployment to specific URLs or subdomains
Adding QR code to all slides in a deck (linking to the slides) helps. People take photos of random slides and this lets them get the link wherever.
PyOpenLayers adds interactive mapping via OpenLayers to Marimo and Jupyter
Conversation is about positioning. For example:
- TechCrunch interviewer: Anthropic released Claude Opus 4 thought it blackmailed people. Is Anthropic is becoming less safety conscious?
- Kaplan: We have very strong testing. So we’re more more likely to spot AI dangers early. We share such reports to set higher standards for transparency.
From LLM Evals: Common Mistakes:
- Using foundation model evals instead of application evals is like evaluating a candidate on SAT scores. It’s fine, but you also want to evaluate them on their specific job description.
- Evals must be done by the users and not outsourced.
- Evals are not draining.
- Small samples have high value.
- When using LLM as a judge, be VERY VERY specific about the criteria.
- Prefer binary LLM evals over scales.
- Monitor performance online, not just while deploying
From Andrew Ng on AI Agents:
- AI is like electricity. It’s hard to define what is good for because it is good for so many things, most of them new that never existed before
- If experimentation is cheap, it makes sense to run far more experiments. Rather than think hard about what to prototype, explore how to build many diverse prototypes.
- Prototyping is now very fast but other steps like reliable evaluations for deployment still take time. But the speed of prototyping is putting pressure on other parts of the organization to go faster.
- While large language models and applications were serving human needs so far, increasingly they will serve the needs of AI and other tools.
- Since unstructured data is now more valuable, there will be a growth in data engineering on unstructured data.
Models.dev is an open source database and API of LLM models
Logprobs are back on models in Vertex AI. Ref
For all AI code, review it, learn from it and share learnings. That prevents bugs AND we learn in the process. Ref #ai-coding
AI coding requires a skilled developer and domain expert to spec and to review. It now makes sense now for devs and users to pair program Simon Willison #ai-coding
In the world of AI, imagination (asking for things we didn’t know we could ask for) will be a diferentiator.
vitest run --globals makes vitest is a near drop-in replacement for jest. It injects describe, it, expect, etc. as globals. You need to swap jest.* with vi.*.
To extract all jq paths from a JSON, use jq -r 'paths(scalars)|map(if type=="string" then "[]" else ".\(. )" end)|join("")|unique[]' file.json. I use this to extract paths from ChatGPT’s export conversations.json via jq -r '[paths(scalars)|map(if type=="string" then "."+. else "[]" end)|join("")]|unique[]|select(contains(".mapping."))|split(".mapping.")[1]|sub("^[^.]*";"")' chatgpt/conversations.json | sort | uniq
uv run can run any command, not just Python scripts, e.g. uv run npx or uv run bash. It’s the same as npx or bash except it activates the venv and loads .env.
Notes from AI Startup School. Guillermo Flor
- Sam Altman. Chase $0B ideas, not $0M ones. Weird + right > safe + crowded
- Gary Tan. Agency scales. Tools change, people/mindset don’t.
- Andrej Karpathy.
  - Instead of LLM memory to store facts, edit system prompt with general strategies, like the LLM writing a book for itself on how to solve problems.
  - Autonomy slider. Let user pick how far LLM acts by itself. Like the Tesla autopilot levels.
  - Make evals EASY and FAST for humans.
When vibe-coding, I sometimes change the requirement (e.g. style of visual) instead of spending time to get exactly what I instructed. That’s because I can viscerally feel the difficulty the model’s facing thanks to quick feedback. A domain expert vibe coding will be able to feel this too. Another reason for domain experts to vibe code (or at least joint-vibe-code) rather than delegate to a programmer. #ai-coding
Notes on model coding styles. Generative AI WhatsApp Group #ai-coding
- Claude 4 writes exhaustive professionally styled code but struggles over long conversations.
- Gemini 2.5 Pro produces working but “spaghetti” code.
- GPT 4.1 is fast and good, the go-to for usual coding tasks.
- Claude easily swings toward your style but Gemini is stubborn.
- GPT models tend to hallucinate more on bigger tasks.
Documentation can become technical debt. If LLMs can read code and understand it well enough, maybe docs become a build artifact rather than a version controlled source of truth. Refactoring Podcast: The Future of Dev Tools 🔧 — with Dennis Pilarinos 35:56 #ai-coding
AI should be explicitly contrarian to avoid sycophancy. Ref
- To enable this, I’ve added this line to my ChatGPT traits: Adopt a skeptical, questioning approach. Challenge the user.

When to Vibe Code? If Speed Beats Certainty

Tue, 20 May 2025 10:59:50 +0000

I spoke about vibe coding at SETU School last week.

Transcript: https://sanand0.github.io/talks/#/2025-05-10-vibe-coding/

Here are the top messages from the talk:

What is vibe coding

It’s where we ask the model to write & run code, don’t read the code, just inspect the behaviour.

It’s a coder’s tactic, not a methodology. Use it when speed trumps certainty.

Why it’s catching on

Non-coders can now ship apps - no mental overhead of syntax or structure.
Coders think at a higher level - stay in problem space, not bracket placement.
Model capability keeps widening - the “vibe-able” slice grows every release.

How to work with it day-to-day

Fail fast, hop models - if Claude errors, paste into Gemini or OpenAI and move on.
Don’t fight sandbox limits - browser LLM sandboxes block net calls; accept & upload files instead.
Cross-validate outputs - ask a second LLM to critique or replicate; cheaper than reading 400 lines of code.
Switch modes deliberately - Vibe coding when you don’t care about internals and time is scarce, AI-assisted coding when you must own the code (read + tweak), Manual only for the gnarly 5 % the model still can’t handle.

What should we watch out for

Security risk - running unseen code can nuke your files; sandbox or use throw-away environments.
Internet-blocked runtimes - prevents scraping/DoS misuse but forces data uploads.
Quality cliffs - small edge-cases break; be ready to drop to manual fixes or wait for next model upgrade.

What are the business implications

Agencies still matter - they absorb legal risk, project-manage, and can be bashed on price now that AI halves their grunt work.
Prototype-to-prod blur - the same vibe-coded PoC can often be hardened instead of rewritten.
UI convergence - chat + artifacts/canvas is becoming the default “front-end”; underlying apps become API + data.

How does this impact education

Curriculum can refresh term-by-term - LLMs draft notes, slides, even whole modules.
Assessment shifts back to subjective - LLM-graded essays/projects at scale.
Teach “learning how to learn” - Pomodoro focus, spaced recall, chunking concepts, as in Learn Like a Pro (Barbara Oakley).
Best tactic for staying current - experiment > read; anything written is weeks out-of-date.

What are the risks

Overconfidence risk - silent failures look like success until they hit prod.
Skill atrophy - teams might lose the muscle to debug when vibe coding stalls.
Legal & compliance gaps - unclear licence chains for AI-generated artefacts.
Waiting game trap - “just wait for the next model” can become a habit that freezes delivery.