Weave Router is a drop-in model-routing layer for agentic systems. Instead of sending every model call in a run to the same LLM, it evaluates each upstream action and chooses from the models you’ve enabled using an in-process ONNX embedder and cluster scorer. It speaks Anthropic, OpenAI, and Gemini APIs, can route to models from providers such as OpenRouter and other OpenAI-compatible endpoints, and works with tools like Claude Code, Codex, Cursor, and custom apps without requiring you to redesign the application around a new API. In the self-hosted setup, the router, scorer, database, and provider keys stay on your machine, while prompts go directly to the configured model provider, routing decisions can also be inspected through traces and analytics.The core idea is simpletreat model selection as a runtime decision for every agent action, rather than hard-coding one model for the entire workflow.

Today, Maya 2 Native Voice gets an upgrade.It moves Indian voice AI beyond customer care and into entirely new consumer experiences.Maya 2 is ranked #1 on the Voice of India leaderboard and is built for the way India actually speaks.This release supports 11 major Indian languages:Hindi (हिन्दी), Telugu (తెలుగు), Bengali (বাংলা), Gujarati (ગુજરાતી), Kannada (ಕನ್ನಡ), Malayalam (മലയാളം), Marathi (मराठी), Odia (ଓଡ଼ିଆ), Punjabi (ਪੰਜਾਬੀ), Tamil (தமிழ்), and Indian English.For too long, voice AI has been designed mostly for customer support. Useful, but rarely something you would want to spend time with.Maya 2 Native Voice is built for more. Voices that carry character. Voices with rhythm, warmth, and expression. Voices that make entirely new consumer products and creative applications possible.Our goal is simple: speech that retains identity, rhythm, and emotional texture across languages.Maya 2 Native Voice brings us closer to expressive, low-latency, production-ready speech for India.Try it here: https://lnkd.in/efPKsxBe

Amazon Web Services (AWS) just shared their real-world lessons from building 1000s of agents at Amazon.Most teams still evaluate like it’s a single LLM call.But agents aren’t just outputs anymore. They’re systems.- multi-step reasoning- tool selection + execution- memory retrieval- multi-agent coordinationIf you only evaluate the final response, you miss why things break.AWS just shared how they evaluate agents internally, and it’s a much more practical approach.They break evaluation into 3 layers:1. Bottom layer: model performance (latency, accuracy, cost)2. Middle layer: components (intent detection, planning, tool use, memory)3. Top layer: final outcome (task success, UX, safety)Instead of asking “did it answer correctly?”, you can localize failure:- planning score: was the task decomposition valid?- tool selection accuracy: was the right capability invoked?- tool call error rate: did execution fail or inputs break?- grounding / faithfulness: did reasoning stay consistent with context?- multi-turn coherence: did state drift over time?Another key shift: evaluating trajectories, not just outputs.Agent traces (reasoning steps, tool calls, intermediate states) become first-class evaluation artifacts.- replay traces against new versions -- regression testing- generate synthetic eval datasets from production logs- benchmark tool-use sequences, not just answersThis is especially critical in multi-agent setups, where failure modes include:- poor task decomposition by the orchestrator- incorrect agent assignment- communication breakdown between agents- inconsistent aggregation of resultsFinally, one thing that consistently shows up in production:You need human-in-the-loop, not as a fallback, but as part of the eval loop.- calibrate LLM-as-a-judge- audit edge-case trajectories- validate reasoning quality, not just correctness♻️ Share it with anyone who is building AI agents in production :)I share tutorials on how to build + improve AI apps and agents, on my newsletter 𝑨𝑰 𝑨𝒈𝒆𝒏𝒕 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈: https://lnkd.in/gaJTcZBRLink to article: https://lnkd.in/eFT45Gsq

AI Engineer vs AI Forward Deployed Engineer (AI FDE) 🚀These two roles may become some of the most interesting career paths in the AI industry.But they solve very different problems.👨‍💻 AI EngineerAn AI Engineer primarily focuses on building AI systems.→ Builds RAG applications→ Develops AI Agents→ Integrates LLM APIs→ Creates evaluation pipelines→ Implements guardrails→ Optimizes latency and cost→ Deploys scalable AI applications→ Builds observability and monitoringThink:"I build the AI system."Now imagine a bank approaches your company and says:"We want an AI assistant that can answer questions from millions of internal documents."This is where the AI Forward Deployed Engineer (AI FDE) becomes interesting.🧑‍🚀 AI FDEThe FDE works closely with the customer and discovers the real problem.The bank might say:→ Our documents are spread across SharePoint, databases and internal APIs→ Different employees have different permissions→ Sensitive data cannot leave our infrastructure→ Every AI response needs citations→ Authentication must integrate with our existing systems→ Compliance requires complete audit logsNow someone has to make the AI system actually work inside this environment.That's the AI FDE.They combine:AI Engineering + Software Engineering + Solution Architecture + Customer Engineering + Business UnderstandingThe easiest way I think about these roles:AI Engineer:"I build the AI engine."AI FDE:"I take that engine into the customer's environment and make it solve a real business problem."And that's an important distinction.An AI FDE is not just a consultant.They don't simply create PowerPoints and recommend architectures.They CODE. BUILD. INTEGRATE. DEPLOY. DEBUG.AI Engineers make AI systems possible.AI FDEs make those systems useful in the real world.As enterprise AI adoption grows, I believe we are going to hear a LOT more about Forward Deployed Engineering. 🚀AI Engineer → Build the technologyAI FDE → Make the technology work for the customerKRISHAI Technologies Private Limited

Someone just open-sourced an AI whiteboard where you handwrite and it reponds in real time.It's called PenEcho. You sketch equations, draw diagrams, scribble notes wherever they make sense. When you pause, it sends that region to the model. The response appears beside your work. Not in a chat window.On the whiteboard itself.The canvas is 20,000 x 20,000 pixels but only loads tiles where ink exists. Each request costs a few cents. Runs locally. Supports Claude, OpenAI, and Codex.The builder said something that stuck with me: six months ago, no model could have done this. Not the handwriting recognition.The fact that it understands unfinished equations, rough diagrams, and the spatial relationship between them. It infers what you meant from incomplete marks.Link: https://lnkd.in/e9BUnSE2This is how research should work. Think on a whiteboard. AI thinks with you. No copy-pasting into a chat box. No breaking your train of thought.

Running locally qwen3.8 27B with dflash using some custom shit found on github on my 3090 getting like 100 tps, context of 64k (nha but usable) -> if I drop the bfloat16 kv cache to int4 I get 250k context with around 55 tps but I prefer speed - TTFT usually around 2.5/3seconds3090 is the best value gpu, a model as good as qwen3.8 27b at more than 100tp/s feels like I live in the future, 2/2.5x times faster than sol - I am using it more and more and it just do whatever I task him to do, legal and illegal - it should do it - it good, very good, extremely good - how it is even possible on my 6 years old gpu!!!!Connected to opencode, it just works perfectlyNext step two set my 3090 to 300w, buy another one on pci 4.0 so I get 250k tokens of context 🔗 https://lnkd.in/ejqHhF3dOWN YOUR AI, YOUR MONEY = YOUR DATA

Clone a human voice in real time without tokenization!VoxCPM is an open-source text-to-speech system that models speech in continuous space instead of discrete tokens.Most TTS systems convert speech to discrete tokens before generation. This quantization creates a fundamental trade-off: tokens provide stability but lose acoustic details like breath, vocal texture, and subtle articulation.VoxCPM skips tokenization entirely.It models speech directly in continuous space using an end-to-end diffusion autoregressive architecture built on MiniCPM-4.The system uses hierarchical language modeling with two specialized components: a Text-Semantic Language Model that captures high-level prosody and structure, and a Residual Acoustic Model that recovers fine-grained acoustic details.This separation eliminates dependency on external speech tokenizers and prevents error accumulation from multi-stage pipelines.Two flagship capabilities:1. Context-aware speech generation: The model comprehends text to infer appropriate prosody and speaking style. Explanations slow down naturally, emphasis appears in the right places, questions sound like questions.2. Zero-shot voice cloning: With just 3-10 seconds of reference audio, it replicates speaker timbre, accent, emotional tone, rhythm, and pacing.Key features:• Tokenizer-free architecture with continuous speech modeling• Context-aware prosody generation without manual tuning• Zero-shot voice cloning from short reference audio• Streaming synthesis support for real-time applications• SFT and LoRA fine-tuning supportIt's 100% open sourceLink to the GitHub repo in the comments!

Asked in an AI Engineer InterviewInterviewer: A simple customer request causes an agent to make 12 LLM calls and 8 tool calls, increasing cost and latency significantly.Question: How would you redesign the agent orchestration and AI Gateway to control token usage, tool calls, model selection, and execution budgets?Explanation:Set execution budgets: Define maximum LLM calls, tool calls, tokens, and execution time per request.Use model routing: Send simple tasks to smaller, cheaper models and complex reasoning to larger models.Reduce LLM calls: Combine related reasoning steps instead of calling the LLM repeatedly.Control tool usage: Allow tools only when necessary and prevent repeated calls with the same inputs.Cache results: Cache repeated LLM responses, embeddings, and tool results.AI Gateway: Centralize model routing, rate limits, token limits, cost tracking, retries, and policies.Early stopping: Stop the agent once the required answer is obtained instead of continuing unnecessary reasoning.Monitor: Track tokens/request, LLM calls, tool calls, latency, cost, and success rate.Preparing for an ML or AI interview or Looking for Transition in AI? Check out the resource below, it covers key concepts with 1000 interview question Answers, Roadmap, Projects and practical topics to help you prepare with confidence.AI Interview Bundle: https://lnkd.in/dez6Ji7E AI Structured Course: https://aptai.in/learn-ai

Your AI agent can now run a full video dubbing pipeline for you.100+ languages. Runs locally. $0.It’s called KrillinAI. You give it a YouTube link or local video and it handles the full workflow from transcription to a finished localized video.→ Transcribes with Whisper options→ Translates into 100+ languages→ Generates TTS dubbing→ Creates horizontal and vertical versions→ Generates platform cover images→ Works on Windows, macOS, and Linux→ Includes CLI skills for AI agentsThe interesting part is the agent workflow.Each stage can run separately, so coding agents can chain subtitles, dubbing, rendering, and cover generation into automated pipelines.Link: https://lnkd.in/evG9u8EHIt supports local speech recognition and OpenAI-compatible local or cloud LLMs. 100% Open Source.

Clone a human voice in real time without tokenization!VoxCPM is an open-source text-to-speech system that models speech in continuous space instead of discrete tokens.Most TTS systems convert speech to discrete tokens before generation. This quantization creates a fundamental trade-off: tokens provide stability but lose acoustic details like breath, vocal texture, and subtle articulation.VoxCPM skips tokenization entirely.It models speech directly in continuous space using an end-to-end diffusion autoregressive architecture built on MiniCPM-4.The system uses hierarchical language modeling with two specialized components: a Text-Semantic Language Model that captures high-level prosody and structure, and a Residual Acoustic Model that recovers fine-grained acoustic details.This separation eliminates dependency on external speech tokenizers and prevents error accumulation from multi-stage pipelines.Two flagship capabilities:1. Context-aware speech generation: The model comprehends text to infer appropriate prosody and speaking style. Explanations slow down naturally, emphasis appears in the right places, questions sound like questions.2. Zero-shot voice cloning: With just 3-10 seconds of reference audio, it replicates speaker timbre, accent, emotional tone, rhythm, and pacing.Key features:• Tokenizer-free architecture with continuous speech modeling• Context-aware prosody generation without manual tuning• Zero-shot voice cloning from short reference audio• Streaming synthesis support for real-time applications• SFT and LoRA fine-tuning supportIt's 100% open sourceLink to the GitHub repo in the comments!

Enterprise AI engineers should not only learn to build RAG from scratch, but do it with open-source modules.We’re excited to release a brand-new tutorial to allow any AI engineer to build a RAG pipeline from scratch using purely local, open-source modules . No API calls to third-party systems!   sentence_transformers embeddingsPostgres + pgvector as the vector storeLlama 2 as the LLM (through llama.cpp)Check out our guide here: https://lnkd.in/gfXE5WQ2

New enterprise uses for generative AI are rapidly emerging, but these 7 applications have already made a real impact.Get answers to the top generative AI questions for your enterprise: https://gtnr.it/40kGu52

Someone built a fully self-hostable NotebookLM-style study platform.It’s called PageLM. You drop in PDFs, DOCX, Markdown, or TXT files, and it turns them into:→ Cornell-style notes→ Flashcards→ Quizzes with explanations→ AI podcasts→ Mock exams→ Homework plans→ Document-grounded chatIt supports GPT, Claude, Gemini, Grok, OpenRouter, and local models through Ollama.You can run PageLM yourself with Node.js or Docker.Link: https://lnkd.in/ejq-CmEnImportant: the code is public, but its custom license is not a standard open-source license. Personal, educational, and non-commercial research use is free. Commercial use requires permission.

Confused by RAG, Agents, MCP and A2A? 🤨They're not competitors. They're four layers of the same stack.RAG → what the system knows. Retrieve, rerank, answer with sources. Most failures here are chunking failures, not retrieval ones.Agents → what the system decides. Plan, act, observe, reflect. The real design choice is the autonomy slider: reads free, writes behind approval.MCP → what the system can touch. Write the tool server once, every compliant client gets access. This is the layer actually working today.A2A → who the system can talk to. Agents delegating to partner agents. Still mostly conference slides, because nobody can answer who is liable when a partner agent gets it wrong.Three are shipping. One isn't. Build the layer that's blocking you, not the layer that demos well.Our round is open from $1,000 with up to 22% bonus shares before August 31: https://lnkd.in/dF2BAWPX

Your documents are full of facts. Most tools still treat them like blobs of text.Introducing Hyper-Extract — an open-source, LLM-powered CLI that turns unstructured documents into structured, queryable Knowledge Abstracts.Parse → Extract → Query → Visualize. All from the command line.What makes it different:🔹 One-command workflow — go from raw document to structured, visualizable output without switching tools🔹 8 knowledge structures — from simple lists and Pydantic models to graphs, hypergraphs, and spatio-temporal graphs🔹 80+ YAML templates — ready-made presets for finance, legal, medical, industry, and general use cases🔹 Pluggable extraction engines — GraphRAG, LightRAG, Hyper-RAG, KG-Gen, and more🔹 Run it fully local — vLLM + Qwen3.5-9B + bge-m3 for extraction and embeddings, no external API requiredFully open-source under Apache 2.0 — built for builders who want structure, not black boxes.🔗 Link in the comments 👇

How have software engineering fundamentals changed with agentic coding? Even when you use a coding agent to write all your code, understanding software fundamentals is important for steering your agent to make the tradeoffs you want — or to even know what tradeoffs exist to be made. Additionally, when you’re building an AI application, the AI core is often expressed through a broader software application, which you will want to help build or shape.A novice who vibe codes without understanding software fundamentals can create simple applications, but this often leads to the coding agent making bad tradeoffs in latency, availability, consistency, reliability, maintainability, simplicity, and/or cost. In such cases, the developer didn’t know such tradeoffs even existed and therefore did not steer the agent to make the right decisions for their application context.This article describes what our study of AI Engineering Skills shows are the most important things to know in software engineering. It requires being skilled at:Building full-stack applicationsManaging dataDesigning system architecturesMaking systems secure and reliableScaling and operating in productionBuilding full-stack applications. Agentic coding enables many developers who previously played more specialized roles (like front-end developer or mobile developer) to play a broader, full-stack role. A coding agent can help with parts of the development process that you might be less familiar with. However, understanding how the full stack actually works is important. Skilled developers understand the key components and concepts of front-end and back-end systems, including UI components, caching, page rendering, API choice and design, authentication, state and session management, asynchronous processing, data persistence, testing, security, and accessibility.Managing data. Data deserves special attention because it is a foundation that software is built on top of, that is relatively hard to change (even if agents help with migrations). When you know how to manage data, you can think through access patterns and use them to decide what to store and for how long. You can identify the right data models and select the appropriate storage types (such as relational tables, documents, key-value, or graphs) and infrastructure, which in turn affects speed, scalability, availability, reliability, and cost. You understand transactions, concurrency, and how to ensure your data is clean, consistent, and fresh. When needed, you can ensure proper privacy, governance, and compliance. You know how to manage the data lifecycle.As an application evolves, you also know how to evolve the data architecture with it. Deciding how to manage data requires significant human-provided context. Your AI systems will get their own input context from your data source, so if data architecture is chosen poorly, the AI doesn’t know what it doesn’t know. This is why it takes skilled intervention from someone with the relevant context and skilled at AI engineering — you! — to set it right. How to build data infrastructure for agents — rather than only traditional software or humans — is also a rapidly evolving area, and you should continue to adjust your best practices as the field evolves.Designing system architectures. When you understand the major components of the full stack of software and data, you are then better positioned to decide how to put the pieces together. Good system design requires understanding what the software is intended to do (how many users? how important is latency? how important is cost? etc.) so you can make choices about the application platform, the boundary between the frontend and backend, system decomposition, application state placement, and architectural granularity (monolith vs. microservices). You will also choose the stack (programming languages, runtimes, component/frontend/backend frameworks, data technologies) — sometimes by running experiments to evaluate options before settling on one.Further, the right architecture is a moving target, depending on the phase of the project. The simple architecture you choose to build a quick prototype may not be the right architecture to build the first production system, and that too may change as the application scales. Making these decisions requires deep technical knowledge of both software components and the application context so you can design — and evolve — the architecture to make better tradeoffs.Making systems secure and reliable. To build reliable systems, you should know how to develop testing strategies to verify the correctness of your system: What mix of unit tests and integration tests, what frameworks to use, and what level of coverage. You also know how to design around possible failures — how to handle failures (like an API hitting a rate limit), build in graceful degradation, and minimize the blast radius of failures. Additionally, rather than first writing software and then later figuring out how to secure it, the “shift left” movement is moving security work earlier in the lifecycle (to the left on a traditional project timeline). Just as all developers are moving toward becoming full stack developers, many developers are now also partly security engineers. You can now use AI tools to scan your code for vulnerabilities, check dependencies for supply chain injections, and examine your cloud configuration for attack surfaces. But doing this well still requires some knowledge of security.Scaling and operating in production. To serve real users, you will have to know how to deploy your software to production. You will benefit from knowing how to execute the software development lifecycle (SDLC) which, in addition to building and testing, includes configuring the deployment environment, deciding on release strategy, applying deployment automation (CI/CD), and understanding infrastructure as a service (IaaS).Operating in production requires putting in place observability tools, setting alerts, and managing incidents. Lastly, to scale your application, you should understand the real load and know how to scale servers, load-balance, and adapt your data infrastructure (via sharding, indexing, replication) or make architecture changes to allow your system to adapt to scale. Finally, understanding coding best practices like version control, code reviews, dependency maintenance, and how to manage technical debt helps you keep evolving your system over time.Coding agents have changed how we build software, including software that does not contain any AI components. Some parts of coding knowledge — like memorizing coding syntax — are becoming obsolete. But developers who deeply understand how software works vastly outperform those who vibe code without understanding.Understanding software fundamentals (in addition to AI) also helps you figure out what software can and cannot do. This makes them important context for how you use coding agents and shape the build. I will discuss these in future posts.

🚨 I've just published Sentence Transformers v6.0, introducing MultiVectorEncoder: ColBERT-style late interaction models are now a fourth model type, for training, inference, and interpretation, alongside the dense, sparse, and reranker models! Details:Where a regular embedding model compresses a whole text into one vector, a multi-vector model keeps one vector per token and scores query against document with the MaxSim operator. That preserves token-level matching information that a single vector has to average away. It is also the state of the art for visual document retrieval, where a text query is matched against page images directly, charts and tables included, with no OCR step in between.LightOn built PyLate on top of Sentence Transformers to close the late interaction gap, and much of what you can load today was trained with it. With v6.0, those capabilities land in Sentence Transformers itself, designed together with PyLate's authors.Any PyLate, Stanford ColBERT, or ColPali checkpoint loads straight into the same familiar API: model.encode_query(), model.encode_document(), and model.similarity() just work, whether the documents are texts or page images.Does it help? LightOn trained LateOn (multi-vector) and DenseOn (dense) on the same data with the same 149M ModernBERT backbone, and the multi-vector model wins on 9 of the 13 NanoBEIR datasets: 0.6868 vs 0.6764 mean NDCG@10. The price is a bigger index, and the new HierarchicalTokenPooling module halves it at roughly no retrieval cost.The release also moves to transformers v5, speeds up multi-column training losses by about 1.25x with a merged forward pass, and fixes a class of silent half precision scoring bugs. One of those matters a lot: a bfloat16 reranker with the default sigmoid activation collapsed its top candidates onto a handful of tied scores, which randomized their order. Upcasting before the activation took NanoBEIR NDCG@10 from 0.18 to 0.68.Antoine Chaffin and Raphael Sourty from LightOn, and I wrote a blog post walking through multi-vector models in practice: loading the various checkpoint formats, encoding and scoring, plugging them into a search stack, running them on page images, and keeping the index affordable. Check it out if you want to get started, or just point your Agent to the URL: https://lnkd.in/enBJiiXrpip install sentence-transformers==6.0.0When I published v5.4, I wrote that it set up the groundwork for introducing late interaction models in the next major release. This is that release, and it is one of the largest updates in the project's history.

What's the difference between ColBERT and ColPali?ColBERT and ColPali are both new retrieval models based on the late interaction mechanism, but how do they differ?ColBERT: Contextualized Late interaction over BERTColPali: Contextualized late interaction over PaliGemmaColBERT: single modality (text-only)ColPali: multimodal (text and images) using VLMsColBERT: documents as text onlyColPali: documents as images (screenshots of PDFs)ColBERT: https://lnkd.in/gaV3mRevColPali: https://lnkd.in/gTf68AgY

The best software I use every day is software I never think about.That is the highest compliment I can pay a product, and Wispr Flow has earned it twice.First with dictation. Somewhere last year I stopped typing and started talking. Specs, updates, hiring notes, half my thinking. 138,802 words this year, almost none of them typed. The keyboard became the exception without me noticing it happen.Then Notetaker arrived and fixed something I had quietly given up on.I used to sit in meetings scribbling, half listening, missing the actual decision because I was still writing down the sentence before it. I would walk out with three bullets and a fuzzy memory of what we agreed.Now I just listen. Properly listen. The notes are waiting when I am done, and my follow-ups are written before I have left the room. What used to take an hour of trying to remember now takes four minutes. It gave me back the ability to be present in my own meetings.Tanay Kothari & Sahaj Garg you have built something I actually enjoy using every day. It does not ask me to change how I work. It just removes what was in the way.That is what I want Creedom to be for creators. Not another tool they have to remember to open. Something that sits inside the work and quietly removes the hard part.The best products do not compete for your attention. They give it back.Nimisha Mehta Vasundhara Bhagat, excited to see where this goes in India.

A guy shared a Claude Code prompt that's literally $300/hr senior engineerHere's the full prompt to copy: P.s. get more Claude resources for absolutely FREE, sign up here: https://lnkd.in/dMGZuZAjPrompt: "Before implementingWork like a contractor who bills for rework: the cost of a wrong assumption is yours to avoid, and the cost of an unnecessary question is mine to pay.1. Investigate before you askRead the relevant code, tests, configs, and dependency manifests first. Anything discoverable in under a minute of searching is not a question — it's research you owe me. Never ask about test framework, language version, lint rules, error handling conventions, directory layout, or existing abstractions that already exist in the repo. If the codebase contradicts itself, that's worth raising.2. Then produce this, and stopGoal. One paragraph restating what I asked for in your own words, including the acceptance criteria you'll hold yourself to. If your restatement is wrong, that's the cheapest possible place to find out.Blocking questions (0–3). Only ask when a wrong answer means throwing work away, not adjusting it. Each question gets your recommended default so I can reply "yes to all" — never ask an open question where a proposed answer would do. If nothing is genuinely blocking, say so and list zero.Assumptions. Numbered, specific, falsifiable. "Inputs are under 10k rows and fit in memory" is an assumption. "The code should be maintainable" is not. Cover whichever of these the task actually touches: - Data: shape, volume, trust level, encoding, what a malformed input looks like - Failure: what should happen on timeout, partial write, or downstream 500 — retry, fail loud, or degrade - Boundaries: who calls this, what's public API vs. internal, backwards-compat obligations - State: concurrency, idempotency, transactionality, ordering guarantees - Environment: runtime version, where it deploys, what it's allowed to reach - Scope: what you're deliberately *not* doing, and what you're leaving as TODO - Testing: what you'll write tests for and what you'll leave uncoveredPlan. Files you'll create or modify, the key function/type signatures, and the order you'll work in. Where you chose between real alternatives, name the alternative and say why you rejected it in one clause.Then wait. Do not begin implementing.3. ProportionalityThis ceremony scales with blast radius. A typo fix, a rename, or a change under ~20 lines with one obvious correct form: just do it. A new module, a schema change, anything touching auth, money, migrations, or deletion: full treatment, and be more suspicious than usual of your own assumptions."Credit: Minchoi