Loading…
Browse by type
Tutorial reads
Tutorial posts on Yomu, summarised newest first.
- 615 posts
- 20 companies
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
Tutorial posts
How to Build an RCS Business Messaging Campaign with Twilio
Rich Communication Services (RCS) upgrades SMS with branded conversations, images, carousels, and read receipts delivered through the default messaging app. Twilio Programmable Messaging supports RCS as a first-class channel, reusing the same API as SMS. This tutorial covers building an RCS campaign in Node.js, including RCS Sender registration (a manual review process with test device support), creating a twilio/card content template with dynamic variables, and broadcasting personalized messages from a JSON list. Delivery status is tracked through a status callback webhook exposed via ngrok, and replies are captured through an inbound webhook when users tap suggested reply buttons. The guide also includes troubleshooting for common issues such as messages falling back to SMS, error codes 30001 and 63001, and webhook configuration errors.
How to Build an RCS Business Messaging Campaign with Twilio in PHP
Twilio’s tutorial explains how to build an RCS Business Messaging campaign in PHP, reusing the same Programmable Messaging API used for SMS. RCS turns standard text messages into branded conversations with images, carousels, verified sender logos, suggested replies, and read receipts delivered through the recipient’s default messaging app. The walkthrough covers registering an RCS Sender, attaching it to a Messaging Service, and designing a rich card template in the Twilio Content Template Builder. It then shows how to broadcast the campaign to a recipient list, track delivery status via a status callback webhook, and capture replies through an inbound webhook. Troubleshooting guidance addresses common issues such as messages falling back to SMS, senders pending approval, and missing status callbacks.
Build golden path CI/CD workflows in Red Hat Developer Hub
This article continues a series on Red Hat Developer Hub, describing how platform engineers create golden path templates to standardize developer workflows. The sample template scaffolds a Go project with a Tekton pipeline, Argo CD manifests, a devfile, and catalog-info.yaml containing annotations that map to enabled plug-ins. Developers use the template from the self-service screen, completing a form to specify application metadata, image registry, OpenShift details, and Git repository. After scaffolding, automated CI/CD is triggered by a Git commit, and developers monitor Tekton PipelineRuns, Argo CD sync status, container images from Quay, and Kubernetes resources from tabs within Developer Hub. The article provides step-by-step instructions for both platform engineers and developers, including template authoring, registration, scaffolding, and subsequent observability.
How to handle real-time interruptions in your AI voice agent
Real-world AI voice agent calls are messy, with background noise, overlapping speech, and callers interrupting mid-sentence. Twilio Conversation Relay handles interruptions through attributes like interruptible, which controls whether caller input stops the agent’s speech, and ignoreBackchannel, which filters out short backchannel phrases. Background noise that sounds like speech can cause false interruptions and garbled transcripts; Twilio’s testing found Deepgram Flux produced zero transcription failures under combined noise, while a tuned Nova-3 setup also succeeded. Turn detection uses either a traditional silence timer or Deepgram Flux’s fused model, which reduces false interruptions by roughly 30% and trims response latency. When a caller interrupts, the app receives an interrupt message with the exact text played before cutoff, allowing it to trim the LLM’s conversation history so the model only remembers what the caller heard.
How to Build an RCS Business Messaging Campaign with Twilio in C#
RCS Business Messaging upgrades SMS with branded conversations featuring images, suggested replies, and read receipts delivered natively on the recipient’s phone. Twilio Programmable Messaging supports RCS via the same API used for SMS, allowing reuse of existing integrations. This tutorial teaches building an RCS campaign in .NET 10, requiring a Twilio account, registered RCS Sender, Messaging Service, ngrok, and a code editor. The process includes creating a rich card template with hero image, dynamic placeholders, and three buttons (Shop the sale, Send promo code, Unsubscribe), then broadcasting personalized messages via the Twilio helper library while capturing status and replies through webhooks exposed by ngrok. Test devices receive messages without waiting for full RCS sender approval, and the server terminal outputs inbound replies and status callbacks in real time.
Running open-Jev in SQL on Databricks
System One decision models such as Jev produce well-calibrated decisions from discrete options and are fast and cheap for large-scale applications, with potential use cases ranging from analyzing customer support transcripts to applying complex decisions at scale. Open-weight versions like SemIf-OpenJev are available, and Databricks enables serving them on governed data using serverless GPUs via AI Runtime, which provides on-demand GPU compute without managing infrastructure. The workflow is packaged in an importable notebook that downloads the model files, logs and registers the model using Express Deployments, and creates a GPU Model Serving endpoint automatically. The endpoint can be called from SQL via ai_query, which supports arbitrary custom model APIs, allowing structured request formats directly from SQL to return selected classifications and option probabilities as structured columns. The example classifies hotel reviews as good or bad, and users can import the notebook, select Serverless GPU, and run all to get started.
Efficient MoE Training for Biological Foundation Models
Mixture-of-experts (MoE) architectures scale model capacity more efficiently than dense transformers by activating only a subset of experts per token, but naive implementations suffer from fragmented expert computation, routing overhead, and memory pressure. NVIDIA Transformer Engine (TE) addresses these bottlenecks with optimized primitives including GroupedLinear for batched expert GEMMs, MXFP8 low-precision training, and a fused GroupedMLP kernel that combines quantization, SwiGLU activation, and routing-weight scaling. The BioNeMo recipe implements these techniques for biological foundation models, using TE’s autocast API for MXFP8 precision and the Sequential API to fuse the gate-up, ScaledSwiGLU, and down projections into a single operation. On eight NVIDIA B200 GPUs, the recipe achieved up to 2.21x the training throughput of the Hugging Face baseline for a Mixtral-8x7B model. The tutorial provides prerequisites, code examples, and configuration commands to reproduce the optimizations.
Self-encrypting VM images for confidential environments hands on
Confidential VM technologies such as AMD SEV-SNP and Intel TDX protect runtime data but leave persistent storage protection to the guest OS. This article demonstrates a method using Fedora Rawhide that combines dm-verity integrity for the immutable base image with a dm-crypt encrypted overlay for mutable parts. The base /usr partition remains verity-protected, while on first boot systemd-repart creates an encrypted root partition with a key sealed to the virtual TPM, ensuring each VM gets a unique key. An overlay filesystem mounts the immutable base under the writable overlay, avoiding a full copy of the base image and reducing boot time significantly in cloud environments. The article also outlines current limitations, including the lack of proof of origin for the overlay partition and the absence of integrity or replay attack protection.
How to Test and Fix Voice AI Agent Prompts with Twilio Conversation Relay and Cekura
This tutorial demonstrates building a voice AI agent with Twilio Conversation Relay, Node.js, and the OpenAI API, then testing and fixing its prompts using Cekura automated platform, a Twilio Startup Searchlight award winner. Conversation Relay manages real-time voice tasks like speech-to-text, text-to-speech, interruption detection, and turn management over WebSockets, while developers control business logic, tools, and AI integration. Cekura defines evaluation metrics, generates test conversations with realistic caller scenarios—interruptions, topic changes, and unexpected requests—and runs baseline tests to uncover prompt gaps. After analyzing failure reports, developers update the system prompt and re-run tests; fixing a fee-waiver bug raised the pass rate from below 70% to the 90-95% target in one refinement. The tutorial emphasizes that prompts are source code requiring version control and automated testing for reliable voice AI agent behavior.
How to Use NVIDIA Warp and MjWarp to Accelerate Robotics Simulation and Learning Workflows
NVIDIA Warp is a Python framework for writing GPU-accelerated kernels that compiles statically typed Python to CUDA. MuJoCo Warp (MJWarp) implements MuJoCo physics on Warp, enabling batched simulation of hundreds to thousands of independent robot environments on NVIDIA GPUs. The core API transition is small: mjw.put_model and mjw.put_data replace mujoco.MjModel and mujoco.MjData, and mjw.step advances the entire batch. Proper throughput measurement requires GPU synchronization and warm-up to avoid timing queue latency instead of actual GPU work. The post demonstrates moving an SO-101 follower arm from a single CPU world to 2,048 parallel MJWarp environments, validating parity and measuring aggregate world-steps per second.
Build OpenJDK container images locally using the standalone S2I tool
Red Hat provides the Red Hat build of OpenJDK for running Java applications on Red Hat OpenShift 4. Developers can use the standalone Source-to-Image (S2I) CLI to build and test OpenJDK container images locally before deploying to a cluster. S2I produces reproducible images by injecting source code into a builder image and running its assemble script. The toolkit supports flags such as –loglevel for detailed output, –environment-file to pass custom JVM settings like G1GC and MaxRAMPercentage, and –as-dockerfile to output a Dockerfile. After building, the image can be tested locally with docker run, then uploaded to the cluster for deployment.
100 Exercises to Learn Rust, Updated
The post announces a major update to the free JetBrains Academy course ‘100 Exercises to Learn Rust,’ which runs inside RustRover. The course teaches Rust through hands-on exercises building a ticket management system across eight chapters from ownership to futures, assuming fluency in another language. The update adds a rebuilt introduction, an FAQ, a final challenge turning the system into an async REST API by editing Cargo.toml and verifying with a requests.http file, visible test assertions, and a dev/release profile experiment. A ‘fast track’ lets experienced users skip to the final challenge to quickly see which areas need revisiting. The post advises using AI for explanations, not code generation, and turning off AI code completion during exercises to maximize learning from getting stuck and working out solutions.
Extend OpenShift Lightspeed with Red Hat Satellite, MCP, and BYOK
The article demonstrates extending Red Hat OpenShift Lightspeed by integrating the Red Hat Satellite MCP server and bring your own knowledge (BYOK). The Satellite MCP server exposes live operational data, such as kernel versions, CVEs, and errata, through the Model Context Protocol. BYOK enriches the assistant with private enterprise knowledge, enabling retrieval-augmented generation (RAG) to combine internal documentation with infrastructure data. The integration requires installing the OpenShift Lightspeed operator and deploying the Satellite MCP server in the openshift-lightspeed project. Authentication is handled by storing the header value in a Secret, and the MCP server expects clients to include appropriate Accept headers for the text/event-stream media type.
Accelerating a ROS 2 Node with an AI Agent and NVIDIA Isaac ROS
GPU acceleration alone does not guarantee fast ROS 2 graphs because messages may still be serialized or copied through CPU memory. NVIDIA contributed the rosidl::Buffer abstraction and CUDA buffer backend to ROS 2 Lyrical, enabling zero-copy transport of GPU-resident payloads between co-located nodes when they share the same host, CUDA device, Linux user, and a supported RMW implementation, with automatic CPU fallback otherwise. An AI coding agent using the migrate-node-to-rosidl-buffer skill can audit an existing CUDA-accelerated node by tracing data movement, running a copy-boundary audit, and implementing a minimal interface-preserving patch. The tutorial demonstrates this on the Depth Anything 3 TensorRT node, updating subscription options and message storage to use CUDA buffer backend without changing the sensor_msgs/msg/Image message definition. The resulting accelerated workload can be deployed on NVIDIA Jetson AGX Thor, preserving standard ROS 2 messages while avoiding unnecessary serialization and host copies.
Turn Your Latest Observations Into Timely Weather Decisions With NVIDIA Earth-2
Weather-sensitive industries can now turn real-time observations into timely decisions using the AI data assimilation tools in NVIDIA Earth-2. The tutorial covers two techniques: Score-Based Data Assimilation (SDA) for constraining diffusion models with point observations, and HealDA for assimilating disparate datasets into a consistent global state. SDA works within downscaling models like CorrDiff and forecasting models like StormCast, guiding denoising steps toward observations without retraining. A concrete example showed SDA reducing wind-speed RMSE by 54% at held-out stations when applied to CorrDiff downscaling over Europe. Earth2Studio provides a unified interface across gridded, conventional, and satellite data sources, making it easy to connect proprietary observations to weather pipelines.
Sending SMS with an Agentic AI using Twilio and Hermes Agent
The author, a Twilio employee, built a personal agentic AI using Hermes Agent and connected it to Twilio SMS to enable phone-based interaction. They chose SMS over a custom Android app because it works out of the box on any phone and globally, making the agent accessible to anyone with the phone number, including non-technical users. The author wired up a toll-free 800 number and tested the setup by sending a text message from a grocery store parking lot, receiving a reply from the agent. The experiment demonstrated that agentic AI can be integrated with legacy protocols like SMS to provide realtime chat capabilities. The author also noted the importance of reading email provider terms of service if creating a new account for the agent.
Automating Twilio Auth Token Detection and Rotation with TruffleHog, Tines, and Slack
Hardcoding Twilio Auth Tokens in source code or exposing them in plaintext leaves communication systems vulnerable to account takeover, toll fraud, and unauthorized exploitation. This tutorial presents an automated detection and rotation pipeline using TruffleHog for secret scanning, Tines for security workflow automation, and Slack for user interaction. TruffleHog scans local directories or remote Git repositories for Twilio secrets, performs live verification via API requests, and outputs results in JSON. Tines ingests detection events through a webhook, parses the results, and triggers a Slack notification with interactive buttons for acknowledgment, scheduling remediation, or immediate rotation. Upon rotation, Tines calls the Twilio Account API to generate a new secondary auth token, displays it in a Slack modal for secure copy, and eventually promotes it to primary, while the old token is revoked.
Financial Crime Mitigation with MongoDB / Part I: Dynamic Customer Profile
This article is the first in a series on building a financial crime mitigation platform with MongoDB as a unified data platform, focusing on the customer onboarding stage. It outlines a three-step process: capturing prospective customer data into a dynamic profile, running candidate basic checks using hybrid search with the $rankFusion operator, and performing compliance verification via network graphs built with $graphLookup. MongoDB’s flexible data model aggregates structured and unstructured data from various sources, enabling a single customer view. The platform supports vectorized profile representations for similarity searches and clustering, all within one cluster without external search engines. The post concludes by noting that the next part will explore AI-enhanced due diligence processes.
Building Secure AI Agents with Microsoft Agent Framework and Auth0: Human-in-the-Loop Approval
The post details how to add secure human-in-the-loop approval to an AI expense agent built with Microsoft Agent Framework and Auth0, completing the four-part series that handles identity, authorization, and action. Because approval is a security-sensitive action requiring the same cryptographic rigor as any authentication event, the agent uses Client-Initiated Backchannel Authentication (CIBA) to push a notification to the manager’s phone instead of accepting chat input. The notification includes a binding message describing the expense by ID, amount, vendor, and context, giving the manager enough information to decide from a lock screen. The agent polls Auth0’s token endpoint until the manager approves or denies, then uses the CIBA-issued access token scoped with approve:expenses to record the decision on a separate Expense API. This design ensures approval decisions are cryptographically bound to the manager’s identity and verifiable by downstream services, completing the secure loop.
What did AI cost you this quarter?
AI infrastructure costs are often billed to a platform team as one lump sum, leaving Finance without a departmental breakdown and teams without feedback on their usage. The post presents a working demo on Red Hat OpenShift AI that attributes requests and token consumption through department-specific MaaS API keys, shared model servers, Prometheus metrics, Perses dashboards, and MLflow traces. In its example, three departments generate 79,420 inference requests and consume 634 million tokens against a $14,200 quarterly bill, while Marketing’s 32% GPU utilization reveals roughly $34,000 in annual waste. The system combines aggregate usage filters with request-level details such as prompts, token counts, latency, and calculated cost, and the post argues that showback helps identify inefficient allocations and model mismatches rather than police teams.
Top topics
- Architecture830
- Performance812
- LLMs648
- Machine Learning617
- Open Source561
- AI Agents542
- AI454
- Developer Experience446
Weekly digest
The best engineering reads, once a week.