Today we are talking about vibe coding, the idea that you can build software by talking to an AI coding tool instead of typing every line yourself.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- Vibe coding research describes a workflow where developers interact with code-generating large language models instead of writing all code directly.

- The practical loop is intent, context, generation, execution, review, revision, and integration.

- OpenAI Codex, Claude Code, and GitHub Copilot cloud agent are examples of AI coding systems that can work with repository context, file edits, commands, tests, or background development tasks.

- GitHub's risk guidance for cloud agents emphasizes security validation, branch boundaries, human review, prompt-injection risk, auditability, and workflow controls.

- Stack Overflow's 2025 Developer Survey reports high AI-tool adoption but low trust in AI output accuracy, which supports the need for review and verification.

- A 2025 productivity study on experienced open-source developers found that early-2025 AI tooling slowed participants in that specific mature-repository experiment, so productivity gains should not be assumed for every task.

Sources:

- https://arxiv.org/abs/2506.23253

- https://openai.com/index/introducing-codex/

- https://code.claude.com/docs/en/overview

- https://docs.github.com/en/copilot/concepts/agents/cloud-agent/about-cloud-agent

- https://docs.github.com/en/copilot/concepts/agents/cloud-agent/risks-and-mitigations

- https://survey.stackoverflow.co/2025/ai

- https://arxiv.org/abs/2507.09089

Smart glasses are not just normal glasses with a camera attached. They are tiny wearable computers that try to understand the world from your point of view. They may include cameras, microphones, open-ear speakers, touch controls, motion sensors, low-power chips, a phone connection, cloud AI, and sometimes a small display.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- Smart-glasses systems usually split work across glasses, phone, and cloud services.

- Dedicated AR chips matter because glasses have strict power, heat, and size constraints.

- Audio-first glasses avoid many optical-display problems but cannot show rich overlays.

- Display glasses add brightness, optics, battery, thermal, weight, and social-design challenges.

- The key system design question is local versus remote processing: latency-sensitive, private, or always-on work should stay as close to the device as practical, while larger AI tasks may need a phone or cloud service.

- Privacy design must account for bystanders, not only the wearer.

Sources:

- https://about.fb.com/news/2023/09/new-ray-ban-meta-smart-glasses/

- https://www.qualcomm.com/news/releases/2023/09/qualcomm-launches-its-next-generation-xr-and-ar-platforms--enabl

- https://blog.google/products-and-platforms/platforms/android/android-xr/

- https://blog.google/innovation-and-ai/models-and-research/google-deepmind/google-gemini-ai-update-december-2024/

- https://www.spectacles.com/

Today we are talking about large language model inference, and the real cost of asking AI one question.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references and terms:

- Inference is the model-serving path used when a trained model answers a request.

- Input, cached input, and output tokens can be priced differently by API providers.

- Prefill is the prompt-processing phase before answer generation begins.

- Decode is the token-by-token generation phase.

- KV cache means key-value cache, the stored attention state used during generation.

- Prompt caching works best when stable repeated prompt content appears as an exact prefix.

- Batching, request scheduling, paged attention, quantization, and model routing are practical inference-cost levers.

- Per-question energy, water, and carbon figures are workload-specific and should not be treated as universal constants.

Sources:

- https://openai.com/api/pricing/

- https://developers.openai.com/api/docs/pricing

- https://developers.openai.com/api/docs/guides/prompt-caching

- https://www.iea.org/reports/energy-and-ai/executive-summary

- https://www.iea.org/reports/energy-and-ai/energy-demand-from-ai

- https://www.iea.org/reports/energy-and-ai/energy-supply-for-ai

- https://docs.nvidia.com/tensorrt-llm/index.html

- https://nvidia.github.io/TensorRT-LLM/

Today we are talking about FIFA's smart ball and VAR, and how technology helps referees make close decisions at the World Cup.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- VAR stands for Video Assistant Referee and is governed by the IFAB VAR protocol.

- The IFAB protocol says VAR is used for clear and obvious errors or serious missed incidents in defined categories, and the referee keeps final authority.

- Connected-ball systems use an inertial motion sensor to help identify ball movement events such as kick or touch timing.

- Semi-automated offside systems combine player tracking, ball-event timing, software-generated lines or models, and video official confirmation.

- Current World Cup coverage has also highlighted the trust layer: missing or delayed visual explanations can create doubt even when the underlying VAR check was performed.

Sources:

- https://www.theifab.com/laws/latest/video-assistant-referee-var-protocol/

- https://www.timesunion.com/sports/article/2026-fifa-world-cup-var-soccer-usmnt-tim-ream-22307534.php

- https://www.fourfourtwo.com/competition/fifa-statement-confirms-cause-of-distrustful-var-error-in-switzerland-vs-qatar

- https://timesofindia.indiatimes.com/technology/tech-news/fifa-world-cup-2026-how-tech-inside-official-match-ball-trionda-makes-it-special/articleshow/131720260.cms

- https://www.digitalcameraworld.com/cameras/action-cameras/fifas-new-referee-cameras-might-be-the-coolest-camera-tech-at-the-2026-world-cup

A modern robot is not just a metal body with an AI brain. It is a real-time software system that has to sense the world, understand what is happening, decide what should happen next, and move safely.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- Figure's Helix 02 announcement frames humanoid autonomy as a hierarchy across semantic reasoning, visuomotor control, and learned whole-body control.

- Figure 03 highlights platform ingredients such as camera redesign, tactile sensing, data offload, inductive charging, and manufacturing traceability.

- Google DeepMind's Gemini Robotics work frames robot models as vision-language-action systems.

- Google DeepMind's on-device robotics work is a useful signal for local low-latency inference on robots.

- NVIDIA's Isaac and Jetson material shows the robotics infrastructure side: simulation, synthetic data, robot learning, accelerated robot middleware, and edge compute.

- ROS 2 Kilted Kaiju is a middleware signal because robots still need action introspection, replay, transport choices, and quality-of-service behavior.

- A June 2026 arXiv paper argues that middleware is becoming a harness layer for Physical AI because learned models affect control, compute, and communication together.

Sources:

- https://www.figure.ai/news/helix-02

- https://www.figure.ai/news/introducing-figure-03

- https://deepmind.google/blog/gemini-robotics-brings-ai-into-the-physical-world/

- https://deepmind.google/blog/gemini-robotics-on-device-brings-ai-to-local-robotic-devices/

- https://developer.nvidia.com/isaac/sim

- https://developer.nvidia.com/isaac/ros

- https://www.nvidia.com/en-us/autonomous-machines/embedded-systems/jetson-thor/

- https://github.com/ros2/ros2_documentation/blob/rolling/source/Releases/Release-Kilted-Kaiju.rst

- https://arxiv.org/abs/2606.09416

Today we are talking about space infrastructure, and why SpaceX is only one visible signal of a much bigger technology shift.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- SpaceX describes Starship as a fully reusable transportation system for crew and cargo to Earth orbit, the Moon, Mars, and beyond.

- NASA's Human Landing System program connects lunar landing systems to Artemis missions that move astronauts between lunar orbit and the surface.

- NASA's Moon-to-Mars Architecture frames exploration as a campaign architecture across missions, science, logistics, and future Mars preparation.

- FAA's Starship/Super Heavy Boca Chica page shows that launch cadence depends on safety, environmental review, mishap investigation, licensing, and site operations.

- NASA LunaNet describes interoperable lunar communication, navigation, timing, detection, and information services.

- Recent reporting on the SpaceX Falcon 9 / AST SpaceMobile BlueBird launch is used as a signal for direct-to-device satellite connectivity, not as a financial claim.

Sources:

- https://www.spacex.com/vehicles/starship/

- https://www.nasa.gov/humans-in-space/human-landing-system/

- https://www.nasa.gov/moontomarsarchitecture/

- https://www.faa.gov/space/stakeholder_engagement/spacex_starship

- https://www.nasa.gov/directorates/heo/scan/engineering/lunanet_interoperability/

- https://www.space.com/space-exploration/launches-spacecraft/spacex-falcon-9-bluebird-8-to-10-direct-to-cell-launch

Local-first architecture is a way of building software where the user's device keeps a real working copy of useful data.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- SQLite says it is likely used more than all other database engines combined and appears across phones, desktops, browsers, and many applications; its page was last updated on April 21, 2026.

- SQLite documents ACID transactions that remain atomic and durable through crashes or power failure.

- MDN describes the origin private file system as widely available, private to a page origin, optimized for performance, and usable from web workers.

- Zero describes reads and writes hitting a local normalized client datastore first, then syncing with the server in the background.

- Electric Sync describes a Postgres read-path sync engine that syncs subsets of data into local apps using shapes, and its shape guide says production apps should request shapes through a backend API for authorization and security.

- Automerge describes local copies that can update offline, sync later, and automatically merge concurrent changes.

Sources:

- https://www.sqlite.org/mostdeployed.html

- https://www.sqlite.org/transactional.html

- https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system

- https://zero.rocicorp.dev/docs/introduction

- https://electric.ax/docs/sync/

- https://electric.ax/docs/sync/guides/shapes

- https://automerge.org/docs/hello/

Today we are talking about passkeys, and why they are replacing password-centric login.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- FIDO defines passkeys as cryptographic credentials tied to a user's account and approved through the device unlock process.

- MDN says Web Authentication protects against phishing because signatures change with the website origin.

- MDN says a stolen public key cannot authenticate without the private key.

- W3C WebAuthn Level 3 describes passkeys as client-side discoverable public key credentials.

- Google describes passkeys as standardized passwordless sign-in across devices, browsers, and operating systems.

- FIDO Credential Exchange defines a secure-by-default format for transferring credentials, including passkeys, between credential managers.

Sources:

- https://fidoalliance.org/passkeys/

- https://developer.mozilla.org/en-US/docs/Web/API/Web_Authentication_API

- https://www.w3.org/TR/webauthn-3/

- https://developers.google.com/identity/passkeys

- https://web.dev/articles/passkey-registration

- https://fidoalliance.org/fido-alliance-credential-exchange-specifications-overview/

It showed the interface, handled clicks, and talked to a server that did most of the real work.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- MDN says Web Workers let web content run scripts in background threads without interfering with the user interface, and workers can make network requests.

- Chrome positions WebGPU as the modern graphics and compute capability for the web.

- MDN says OPFS is private to the origin, optimized for performance, and offers in-place write access.

- Chrome's SQLite Wasm article shows OPFS-backed persistence and worker-based execution.

- Cloudflare Workers shows the wider market treating web-style runtimes as serious compute surfaces with stateful storage and workflows.

Sources:

- https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers

- https://developer.chrome.com/docs/web-platform/webgpu

- https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system

- https://developer.chrome.com/blog/sqlite-wasm-in-the-browser-backed-by-the-origin-private-file-system/

- https://developers.cloudflare.com/workers/

Structured outputs are the pattern where an AI model returns data that is shaped to match a schema your software defines in advance.

In this episode, Satish uses a simple real-life example first, then turns the idea into a practical technical mental model for engineers and curious builders.

In Simple Terms with Satish: daily tech trends explained simply, with enough technical depth for builders.

Production note: This episode uses authorized synthetic narration based on Satish's own voice. The topic, script, and final editorial approval are by Satish.

Engineer notes:

Exact technical references:

- OpenAI says Structured Outputs ensures responses adhere to a supplied JSON Schema.

- OpenAI says Structured Outputs, unlike JSON mode, guarantees schema adherence.

- Gemini says structured outputs use a provided JSON Schema for predictable, type-safe results.

- Gemini positions structured outputs for extraction, classification, and agentic workflows.

- JSON Schema says object `properties` are not required by default.

- JSON Schema uses `required` to declare mandatory fields.

- JSON Schema documents object-boundary controls like `additionalProperties` and `unevaluatedProperties`.

Sources:

- https://developers.openai.com/api/docs/guides/structured-outputs

- https://ai.google.dev/gemini-api/docs/structured-output

- https://json-schema.org/understanding-json-schema/reference/object