<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Bryan Pesquera on Medium]]></title>
        <description><![CDATA[Stories by Bryan Pesquera on Medium]]></description>
        <link>https://medium.com/@bryan.pesquera?source=rss-151df39fd664------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*3UBZJK-QglefxbaiQaWgLQ.jpeg</url>
            <title>Stories by Bryan Pesquera on Medium</title>
            <link>https://medium.com/@bryan.pesquera?source=rss-151df39fd664------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 17:20:04 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@bryan.pesquera/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Why Quantum Computers Aren’t Just Faster Computers]]></title>
            <link>https://medium.com/@bryan.pesquera/why-quantum-computers-arent-just-faster-computers-dce7e9176410?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/dce7e9176410</guid>
            <category><![CDATA[emerging-technology]]></category>
            <category><![CDATA[quantum-computing]]></category>
            <category><![CDATA[physics]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[computer-science]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Wed, 18 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-18T15:11:01.502Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mYLKIcHY3zYpG-FFhQkFsQ.png" /><figcaption>Quantum computers use qubits, superposition, and interference to perform certain computations differently from classical systems.</figcaption></figure><p>Quantum computers are often described as machines capable of solving problems millions of times faster than ordinary computers. Some explanations even suggest they can explore every possible solution simultaneously, making conventional computers seem almost obsolete.</p><p>But that’s not how quantum computing works.</p><p>Quantum computers aren’t simply more powerful versions of the computers we already use. They operate according to different physical principles, allowing them to approach certain mathematical problems in ways that classical computers cannot efficiently reproduce using currently known methods.</p><p>The distinction begins with how they represent information.</p><h3>Bits, Qubits, and Superposition</h3><p>Conventional computers process information using bits. Each bit represents either a 0 or a 1, and billions of these binary values are manipulated to execute programs, store information, and perform calculations.</p><p>Quantum computers use <em>qubits</em>, which behave differently because they follow the principles of quantum mechanics.</p><p>A qubit can exist in a state called <em>superposition</em>, where its state is described by a combination of 0 and 1 rather than one definite classical value.</p><p>When multiple qubits interact, their combined quantum state can represent a mathematical combination of many possible configurations.</p><p>This is where a common misconception appears: quantum computers do not simply calculate every possible answer simultaneously and then reveal the correct one.</p><p>Measuring a quantum system produces a limited amount of classical information. You cannot directly inspect every possible configuration represented within its quantum state.</p><p>Instead, quantum algorithms must manipulate that state to increase the likelihood of obtaining a useful result.</p><h3>What Actually Makes Quantum Computing Powerful?</h3><p>One of the most important mechanisms is <em>quantum interference</em>.</p><p>Quantum states have properties called probability amplitudes. These amplitudes can reinforce or cancel one another through carefully designed quantum operations.</p><p>A quantum algorithm can exploit this behavior to increase the probability of measuring a desired result while reducing the probability of less useful outcomes.</p><p>Consider searching through an unstructured collection of possibilities.</p><p>A classical algorithm may need to examine possibilities individually. Grover’s quantum search algorithm can reduce the number of required queries from a quantity proportional to the number of possibilities to one proportional to its square root.</p><p>That’s a meaningful mathematical advantage, but it isn’t the same as instantly evaluating every possible solution.</p><p>And importantly, not every problem has a quantum algorithm that provides such an advantage.</p><h3>Why Aren’t Quantum Computers Used Everywhere?</h3><p>Quantum computers are particularly promising for specialized applications, including simulating quantum systems and solving certain mathematical problems.</p><p>For example, Shor’s algorithm demonstrates that a sufficiently capable, fault-tolerant quantum computer could factor large integers efficiently, potentially threatening widely used forms of public-key cryptography.</p><p>However, quantum computers aren’t inherently better at ordinary tasks such as browsing websites, processing documents, or running business applications.</p><p>They also face substantial engineering challenges.</p><p>Qubits are highly sensitive to environmental interference and imperfect operations. Maintaining accurate computations requires sophisticated hardware and, for large-scale applications, quantum error correction.</p><p>Current quantum systems remain limited by noise, error rates, and the difficulty of scaling reliable quantum operations.</p><p>Even when a quantum algorithm offers a theoretical speed advantage, that doesn’t automatically translate into better performance on existing hardware.</p><h3>A Different Kind of Computer</h3><p>The significance of quantum computing isn’t that it will eventually replace every conventional processor.</p><p>Its potential lies in solving particular classes of problems using computational methods based on quantum mechanics.</p><p>Classical computers remain extremely effective for most everyday workloads, while quantum processors may eventually become valuable specialized components within larger computing systems.</p><p><strong>Quantum computing isn’t about making ordinary computers faster. It’s about using fundamentally different physical properties to perform certain computations more efficiently.</strong></p><p>That distinction is what makes the technology scientifically important, even if its most transformative practical applications are still being developed.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dce7e9176410" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How Much Can You Actually Do With a Small Home Server?]]></title>
            <link>https://medium.com/@bryan.pesquera/how-much-can-you-actually-do-with-a-small-home-server-c1539909ca1f?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1539909ca1f</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[cloud-computing]]></category>
            <category><![CDATA[linux]]></category>
            <category><![CDATA[self-hosting]]></category>
            <category><![CDATA[homelab]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-16T15:11:01.532Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Exploring the practical capabilities, limitations, and economics of running useful applications and services on affordable computing hardware.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*iqOhQ9xF6CMR8GRlZrC5-w.png" /><figcaption>A compact home server can support development environments, containerized applications, automation, and self-hosted services, offering a practical way to explore computing infrastructure without specialized enterprise hardware.</figcaption></figure><p>Cloud computing has made it remarkably convenient to deploy applications without owning or maintaining physical infrastructure. A developer can provision a virtual machine, deploy a database, or make an application accessible through the internet without giving much thought to the physical hardware supporting it. For organizations, this flexibility has fundamentally changed how infrastructure is acquired and operated. For individuals and smaller development projects, however, it also raises an interesting question about which workloads genuinely need cloud infrastructure in the first place.</p><p>Many of the services developers use regularly have relatively modest computing requirements. A small database, an internal web application, a monitoring service, or an automation tool may spend much of its time waiting for requests rather than actively consuming processing resources. When those workloads are personal, experimental, or limited to a small number of users, the infrastructure required to support them can be considerably less demanding than the environments commonly associated with enterprise computing.</p><p>This creates an opportunity to reconsider hardware that might otherwise be overlooked. Compact desktop computers, refurbished office machines, and inexpensive mini PCs can provide useful computing capacity without requiring dedicated server equipment or an elaborate home lab. With a suitable operating system and basic networking, even a modest computer can support multiple services and become a flexible environment for development, experimentation, and self-hosting.</p><p>The more interesting question is not simply how many applications can run on a small server, but which workloads make practical sense, where the limitations begin to emerge, and whether maintaining the infrastructure is worth the responsibility.</p><h3>Defining What a Small Home Server Actually Needs</h3><p>The term <em>server</em> often brings to mind racks of specialized equipment, redundant power supplies, enterprise processors, and extensive storage systems. These components serve important purposes in environments that require high availability, substantial processing capacity, or centralized management, but they are not prerequisites for running useful services.</p><p>At its core, a server is simply a computer providing resources or functionality to other systems. A conventional desktop can perform that role just as effectively when its specifications and reliability are appropriate for the workload.</p><p>Consider a representative system built around an Intel Core i5 processor, 16 GB of memory, and a 1 TB solid-state drive. The specific processor generation matters considerably, as different models offer different performance characteristics, power consumption, virtualization capabilities, and thermal behavior. Nevertheless, this general configuration provides a useful starting point for examining what can be accomplished without investing in specialized hardware.</p><p>For many lightweight services, processing power is unlikely to be the first limitation encountered. Applications that remain idle between requests may consume relatively little CPU time, even when several are running simultaneously. Memory often becomes more important as the number of services increases, particularly when databases, virtual machines, and background processes compete for the same resources.</p><p>Storage introduces another consideration. A 1 TB SSD offers enough capacity for an operating system, development environments, application files, container images, and reasonably sized databases. However, its suitability depends on how the storage is used. Large media libraries, continuous video recording, intensive database writes, and extensive backups can consume capacity or contribute to drive wear much more quickly than a collection of lightweight services.</p><p>Networking is equally important. A wired Ethernet connection generally provides a more predictable foundation for a server than relying exclusively on wireless connectivity, particularly when multiple devices access the same services or large files are transferred across the network.</p><p>None of these components needs to be exceptional for a small server to be useful. The objective is to establish a balanced configuration that can support the intended workloads without introducing unnecessary hardware complexity.</p><h3>Containers Make Small Systems More Versatile</h3><p>One of the most significant developments enabling practical self-hosting is the accessibility of containerized applications.</p><p>Traditionally, running several services on a single computer could require manually installing dependencies, configuring application environments, and managing potential conflicts between different software packages. Containers provide a more structured way to package applications with their dependencies while allowing them to share the underlying operating system.</p><p>Tools such as Docker make it possible to run multiple isolated application environments on the same Linux machine. Docker Compose extends this approach by allowing developers to define services, networks, and persistent storage within configuration files, making application environments easier to reproduce and maintain.</p><p>For a small home server, this can be particularly useful. A developer might run a web application, a PostgreSQL database, an automation service, and a lightweight monitoring interface without needing to dedicate an entire virtual machine to each component.</p><p>Containers still consume resources, and isolation does not mean an application cannot affect the underlying system. A poorly configured service can exhaust available memory, occupy excessive storage, or create security risks through unnecessarily exposed interfaces. Nevertheless, containerization provides a practical balance between flexibility and operational overhead for many self-hosted workloads.</p><p>Virtualization offers another approach. Platforms such as Proxmox Virtual Environment allow a physical computer to host separate virtual machines and Linux containers, providing stronger operating system separation and more flexibility when experimenting with different environments.</p><p>The tradeoff is that virtual machines generally require more resources than applications running directly in containers on a shared operating system. With 16 GB of memory, several modest virtual machines may be reasonable, but allocating too much memory to guests can leave insufficient capacity for the host and other workloads.</p><p>For an initial build, I would favor a conventional Linux installation with Docker when the goal is to operate a small collection of applications. A virtualization platform becomes more attractive when experimenting with operating systems, testing isolated environments, or learning infrastructure administration is itself part of the objective.</p><h3>What Can You Realistically Host?</h3><p>A small server can support a surprisingly broad collection of workloads, provided they are selected with realistic expectations about resource consumption and concurrent activity.</p><p>Development environments are among the most practical applications. Hosting test databases, internal APIs, web applications, Git-related services, or containerized development stacks can reduce dependence on external infrastructure for projects that do not require public availability.</p><p>A persistent development server also offers continuity between workstations. Instead of recreating an environment on every computer, developers can maintain a centralized location for applications, supporting services, and experimental deployments.</p><p>Automation represents another useful category. Scheduled scripts, file-processing utilities, webhooks, and workflow automation tools often have limited resource requirements. A dedicated machine allows these tasks to operate independently of a primary desktop or laptop, which may be shut down or disconnected throughout the day.</p><p>Home infrastructure services can also benefit from a small, continuously available computer. Home Assistant, for example, supports installation on conventional x86–64 hardware, as well as deployment through supported container and virtual machine configurations. Similar environments can host local DNS utilities, network monitoring, and other services that support devices within a home network.</p><p>Storage and file synchronization are possible as well, although the design needs to account for the distinction between available disk space and reliable data protection. A computer with a single SSD can provide a convenient location for files, but it should not automatically be treated as a dependable backup system.</p><p>If the drive fails, the server is stolen, or the operating system becomes corrupted, information stored only on that machine may be lost. Important data should have independently maintained backups, ideally including a copy outside the physical location of the server.</p><p>These workload categories illustrate why a small server can be useful without requiring particularly sophisticated hardware. Many applications benefit more from continuous availability, predictable configuration, and centralized management than from substantial raw computing power.</p><h3>Exploring Local Artificial Intelligence</h3><p>Local AI inference introduces another interesting possibility for personal computing infrastructure.</p><p>Tools such as Ollama have made it more accessible to run supported language models on personal hardware without requiring every inference request to be processed by a remote provider. This can be useful for experimentation, privacy-sensitive prototypes, and applications where direct control over the model environment is desirable.</p><p>However, local AI places different demands on hardware than conventional web services.</p><p>Language model inference depends heavily on memory capacity, memory bandwidth, processing performance, and, when available, GPU acceleration. The requirements vary substantially according to the model architecture, parameter count, quantization, and context length.</p><p>A system with 16 GB of RAM can be a reasonable environment for experimenting with selected smaller quantized models, but that does not imply it can efficiently run every model that fits within its available memory.</p><p>Without a suitable GPU, inference may rely primarily on the CPU. Responses can still be generated, but throughput and latency may be limiting factors, particularly for longer prompts or concurrent requests.</p><p>Adding a GPU can improve performance when the model and its working memory fit appropriately within the available video memory. However, doing so introduces additional considerations involving power consumption, cooling, hardware compatibility, and acquisition cost.</p><p>There is also an important distinction between local inference and model training. A machine capable of running a small language model for experimentation is not necessarily suitable for training large models or serving many simultaneous users.</p><p>For a small home server, I would treat local AI as an experimental capability rather than the primary justification for the hardware unless its actual performance has been measured.</p><p>Practical experiments could include comparing response latency across supported models, measuring memory consumption, observing CPU utilization, and evaluating the difference between CPU-based and GPU-accelerated inference where suitable hardware is available.</p><p>These measurements would provide a better understanding of the system’s capabilities than relying solely on published model sizes or theoretical hardware specifications.</p><h3>Where the Limitations Begin to Appear</h3><p>The limitations of a small server become more noticeable as workloads grow beyond lightweight services and occasional development activity.</p><p>Memory pressure is one of the most common constraints. A database may perform comfortably under modest usage but consume substantially more memory as its working dataset expands. Running several virtual machines, development tools, and local AI models concurrently can quickly exceed the practical capacity of a 16 GB system.</p><p>Processing limitations are also workload-dependent. Multiple idle applications may coexist without difficulty, while a single demanding operation can consume most of the available CPU capacity. Video transcoding, large compilation tasks, complex database queries, and model inference may affect the responsiveness of other services when resources are shared.</p><p>Storage performance can become important when several applications perform frequent reads and writes. Although SSDs generally offer strong performance for personal workloads, sustained write activity, available capacity, and the characteristics of the storage interface still influence overall behavior.</p><p>Thermal design introduces another consideration. Compact systems have less space for cooling than conventional desktop towers, and sustained workloads may cause some processors to reduce performance to remain within their operating temperature limits.</p><p>Networking can become a constraint when services are accessed outside the home. A local Ethernet connection may provide excellent performance within the network, while the internet connection’s upload capacity limits how quickly remote users can retrieve files or interact with hosted services.</p><p>These limitations are not necessarily reasons to avoid small hardware. They demonstrate why workloads should be evaluated individually and why expected concurrency matters as much as the number of installed applications.</p><p>A machine running ten mostly idle services may perform better than one running two computationally demanding applications continuously. Counting services alone provides little information about actual infrastructure capacity.</p><h3>Remote Access, Security, and the Responsibility of Ownership</h3><p>Operating a personal server introduces security responsibilities that are easy to underestimate during initial experimentation.</p><p>When an application runs locally on a development computer, its exposure may be limited to that machine. Moving the same application onto an always-on server creates an environment that may be accessible to additional devices or users.</p><p>The appropriate security controls depend on the application, but basic responsibilities include maintaining updates, protecting administrative access, separating services where necessary, and avoiding unnecessary exposure to the public internet.</p><p>Remote access deserves particular attention. Opening ports on a home router can make a service reachable from outside the network, but it also creates an entry point that needs to be maintained and secured.</p><p>Private networking solutions such as Tailscale provide another approach by allowing authorized devices to communicate through encrypted connections without requiring conventional public port forwarding. This can be especially useful for development environments, administrative interfaces, and services intended only for personal use.</p><p>Private network access does not eliminate the need for authentication, updates, or careful configuration. It does, however, offer a useful way to reduce unnecessary public exposure.</p><p>Operational reliability is another part of ownership. A home server depends on residential electricity, local networking equipment, an internet service provider, and hardware that may not include the redundancy commonly associated with enterprise infrastructure.</p><p>A power interruption, router failure, or damaged storage device can make hosted services unavailable. An uninterruptible power supply can provide time for a controlled shutdown during shorter interruptions, but it does not replace backups or create continuous availability during an extended outage.</p><p>For applications supporting only personal experiments, these limitations may be entirely acceptable. For services that other people depend on, the consequences become more significant.</p><p>The important question is whether the reliability requirements of the workload match the environment in which it is being hosted.</p><h3>The Economics of Running a Small Server</h3><p>One reason personal servers are attractive is the possibility of reducing recurring infrastructure expenses.</p><p>Cloud services generally convert infrastructure ownership into ongoing operating costs. Rather than purchasing hardware, users pay for virtual machines, managed databases, storage, networking, or other services according to the provider’s pricing model.</p><p>A home server introduces a different cost structure. The hardware is acquired upfront, while electricity, connectivity, maintenance, backup storage, and eventual replacement contribute to its continuing cost.</p><p>Electricity consumption is worth examining because a server intended to operate continuously accumulates energy usage even when its average power draw is relatively low.</p><p>For example, consider a hypothetical system averaging 25 watts at the wall throughout the year. Operating continuously, it would consume approximately 219 kilowatt-hours annually. At an illustrative electricity rate of $0.18 per kilowatt-hour, the direct electricity cost would be approximately $39 per year, or a little over $3 per month.</p><p>This example is not a measured result for a particular computer. Actual consumption depends on the processor, motherboard, memory, storage, power supply, connected peripherals, and workload. A machine averaging 40 watts would consume substantially more electricity over the same period, while a more efficient system operating at a lower average load could use less.</p><p>The calculation also excludes networking equipment, cooling overhead, backup hardware, and other costs that may already exist or be introduced alongside the server.</p><p>Acquisition cost creates another distinction. Repurposing a computer that is already available can make experimentation inexpensive because there is little additional hardware investment. Purchasing a new machine solely to replace a low-cost cloud service may produce a less compelling financial outcome once the initial expense is considered.</p><p>There is also the cost of time. Updating software, investigating failures, maintaining backups, and replacing failed components are operational responsibilities that a managed cloud service may handle partly or entirely on the user’s behalf.</p><p>For someone interested in learning infrastructure engineering, that work may represent part of the benefit. For someone who simply needs an application to remain available, it may be an unnecessary burden.</p><h3>When Cloud Infrastructure Still Makes More Sense</h3><p>The case for small home servers should not be interpreted as an argument against cloud computing.</p><p>Cloud providers offer infrastructure capabilities that are difficult to reproduce economically within a residential environment. Geographic availability, managed backups, scalable resources, redundant networking, and operational support can provide substantial value when applications have more demanding requirements.</p><p>A public application serving users across multiple regions, for example, may benefit from hosting close to its audience and from infrastructure designed to accommodate variable demand. A production database supporting important business processes may require recovery guarantees and administrative controls that extend beyond what a basic personal server can reasonably provide.</p><p>Cloud services are also attractive for workloads that need substantial computing resources for relatively short periods. Renting additional capacity for an occasional batch job may be more practical than purchasing hardware that remains underutilized most of the year.</p><p>A hybrid approach can provide a useful balance.</p><p>Development environments, internal tools, and experimental services can operate locally, while public applications and critical components remain hosted on infrastructure designed for their reliability and availability requirements.</p><p>This separation also creates opportunities to learn how applications behave across different deployment environments. A service developed in a local container environment may later be deployed to a cloud platform with relatively limited changes, provided its configuration, networking, and persistent storage have been designed appropriately.</p><p>The goal should not be to move everything away from the cloud. It should be to use infrastructure that is proportionate to the requirements of each workload.</p><h3>Building a Useful Server Without Overengineering It</h3><p>For a first home server, I would begin with a relatively small collection of services rather than attempting to build a complete home lab immediately.</p><p>A conventional Linux installation can provide a straightforward foundation. Containers can then be used to deploy applications with reasonably consistent configuration, while persistent data is stored in clearly identified locations that can be backed up independently.</p><p>The initial environment might include a small database, a development application, a monitoring service, and one practical utility such as a file-processing or automation tool. These workloads provide enough variation to evaluate CPU utilization, memory consumption, storage behavior, and networking without introducing excessive complexity.</p><p>The next step should be measurement.</p><p>A basic power meter can establish the server’s idle and active electricity consumption. System monitoring tools can reveal memory pressure, CPU utilization, disk activity, and resource usage over time. Application logs and simple availability checks can help identify failures or performance problems.</p><p>Rather than adding services until the system becomes unresponsive, I would evaluate how the machine behaves during normal usage and under occasional concurrent activity. It is particularly useful to observe whether performance deteriorates when background jobs, database operations, and interactive requests occur at the same time.</p><p>Those findings can guide hardware decisions.</p><p>If memory is consistently constrained, increasing RAM may provide more practical value than replacing the processor. If storage capacity or resilience becomes the problem, additional drives and a proper backup strategy may be more important than adding computing power. If sustained CPU-intensive workloads dominate the system, a more capable processor or specialized hardware may be justified.</p><p>The principle is to let observed limitations determine the next investment rather than building toward an arbitrary hardware specification.</p><p>This approach also prevents a relatively inexpensive experiment from becoming an unnecessarily expensive infrastructure project.</p><h3>A Small Server as an Engineering Learning Environment</h3><p>Beyond the services it can host, a personal server provides an opportunity to work directly with infrastructure concepts that are often abstracted away by managed platforms.</p><p>Networking, access control, process isolation, storage management, deployment automation, monitoring, and failure recovery become practical responsibilities rather than topics encountered exclusively through documentation.</p><p>A developer can observe what happens when a container loses connectivity, how an application behaves after a restart, or why persistent storage needs to be treated differently from disposable application instances.</p><p>These experiments can be particularly valuable because they expose the relationship between software design and the environment in which software operates.</p><p>They also create opportunities to explore tradeoffs without the constraints of a production system. Different deployment approaches can be compared, services can be rebuilt, and architectural decisions can be evaluated through direct observation.</p><p>Not every experiment will result in an application worth maintaining indefinitely. Some of the most useful outcomes may involve learning that a particular workload requires more resources than expected or that an existing managed service provides a better operational solution.</p><p>That is still useful engineering knowledge, especially when it informs future decisions about application architecture and infrastructure ownership.</p><h3>Is a Small Home Server Actually Worth It?</h3><p>A modest home server can support a meaningful collection of applications, development environments, and network services without requiring specialized enterprise equipment. For workloads with limited concurrency and moderate resource requirements, a compact system may provide more than enough capability to justify its place in a personal computing environment.</p><p>However, the benefits extend beyond hardware specifications. A server becomes useful when it solves a recurring problem, supports a meaningful project, or provides an environment for experimentation that would otherwise be inconvenient or costly.</p><p>The limitations are equally important. Memory capacity, sustained processing performance, storage reliability, network availability, and operational maintenance determine which workloads remain practical over time. Running applications locally also transfers responsibilities that might otherwise be handled by a cloud provider.</p><p>For developers interested in understanding infrastructure more deeply, those responsibilities can be valuable opportunities to learn. For users seeking the simplest possible way to operate a reliable public service, a managed platform may still be the more appropriate choice.</p><p>The most sensible approach is to begin with a clear purpose, use available hardware where practical, and expand only when actual requirements justify additional complexity. A small home server does not need to replace the cloud or become an elaborate collection of equipment to be worthwhile. Its value comes from providing useful computing capacity at a scale that matches the problems it is intended to solve.</p><h3>Further Reading</h3><p>The following resources provide useful starting points for exploring the technologies discussed in this article.</p><p><strong>Docker Engine and Docker Compose</strong></p><p><a href="https://docs.docker.com/engine/install/">https://docs.docker.com/engine/install/</a></p><p><a href="https://docs.docker.com/compose/">https://docs.docker.com/compose/</a></p><p>Official documentation for running containerized applications and managing multi-service environments.</p><p><strong>Proxmox Virtual Environment</strong></p><p><a href="https://www.proxmox.com/en/products/proxmox-virtual-environment/overview">https://www.proxmox.com/en/products/proxmox-virtual-environment/overview</a></p><p>A virtualization platform for experimenting with virtual machines, containers, storage, and infrastructure management.</p><p><strong>Home Assistant</strong></p><p><a href="https://www.home-assistant.io/installation/">https://www.home-assistant.io/installation/</a></p><p>Installation options for running home automation software on dedicated hardware, virtual machines, and containers.</p><p><strong>Ollama</strong></p><p><a href="https://docs.ollama.com/">https://docs.ollama.com/</a></p><p>Documentation for exploring supported language models and local AI inference.</p><p><strong>Tailscale</strong></p><p><a href="https://tailscale.com/docs/">https://tailscale.com/docs/</a></p><p>Documentation for establishing private connectivity between devices and accessing self-hosted services remotely.</p><p><strong>U.S. Energy Information Administration</strong></p><p><a href="https://www.eia.gov/electricity/monthly/">https://www.eia.gov/electricity/monthly/</a></p><p>Electricity pricing and consumption information that can help inform estimates of operating costs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c1539909ca1f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Prompt Engineering Is More Than Asking Better Questions]]></title>
            <link>https://medium.com/@bryan.pesquera/prompt-engineering-is-more-than-asking-better-questions-3474e5297ff2?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/3474e5297ff2</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[ai-tutorial]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[generative-ai]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Fri, 13 Nov 2026 15:11:02 GMT</pubDate>
            <atom:updated>2026-11-13T15:11:02.055Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How clear instructions, relevant context, defined constraints, and measurable expectations can turn an ordinary AI request into a more dependable workflow.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UahRiZJD0GToz7-0GcRJUQ.png" /><figcaption>Effective prompt engineering transforms vague requests into structured instructions, using clear objectives, relevant context, defined constraints, and consistent output formats to produce more reliable AI responses.</figcaption></figure><p>One of the most common pieces of advice for working with artificial intelligence is to write better prompts. The suggestion makes sense at first. When an AI assistant produces an unsatisfactory response, changing the wording of the request can often improve the result. Adding details, clarifying expectations, or providing examples may help the system understand what is being asked.</p><p>However, prompt engineering involves more than finding the right combination of words. When AI is used for a repeatable task, especially one that supports an application or business process, the objective is not simply to receive an impressive response. It is to define an interaction that produces useful, appropriately constrained results across different inputs.</p><p>This requires thinking about prompts as specifications for how a task should be performed. A well-designed prompt communicates the objective, provides necessary information, establishes boundaries, and defines what an acceptable result should look like. It also makes the behavior easier to evaluate when the model produces an unexpected answer.</p><p>To explore these principles, we will develop a small example involving an AI assistant responsible for categorizing IT support requests. The example is deliberately simple, but the same approach can be applied to document analysis, information extraction, content classification, and many other common AI tasks.</p><h3>Start With a Task, Not Just a Question</h3><p>Imagine an organization receives support requests describing problems with computers, applications, user accounts, and network connectivity. An AI assistant is being considered to help categorize incoming requests before they are reviewed by the appropriate support team.</p><p>An initial prompt might look like this:</p><pre>Categorize this IT support ticket.</pre><p>The request communicates a general objective but leaves several important decisions undefined. What categories are available? Can the AI create new categories? Should it explain its reasoning? What happens when a request is ambiguous or lacks enough information?</p><p>A language model may still generate a plausible response, especially when the request contains familiar technical terminology. However, different inputs or executions may produce different classification labels, levels of detail, and assumptions about how the organization handles support requests.</p><p>The issue is not necessarily that the model misunderstands the task. The issue is that the task has not been specified sufficiently for consistent operational use.</p><p>We can begin improving the prompt by establishing the expected classification system.</p><pre>Classify the following IT support request into<br>exactly one of these categories:</pre><pre>- Access<br>- Hardware<br>- Software<br>- Network</pre><pre>Provide the selected category and a brief<br>explanation of your decision.</pre><p>This version introduces a defined set of possible outcomes. Instead of allowing the model to invent categories, it establishes an explicit boundary around the classifications the application is prepared to accept.</p><p>That is a meaningful improvement, but we still need to address uncertainty and define how the result will be used.</p><h3>Provide Context That Supports the Decision</h3><p>Context helps a model distinguish between possible interpretations of a request.</p><p>Consider the following fictional support ticket:</p><blockquote><em>I received a new laptop yesterday, but I can’t sign in to my company account. My password works on another computer.</em></blockquote><p>Without additional guidance, the request might be classified as a hardware problem because it mentions a new laptop. Another response might classify it as an access problem because the employee cannot sign in.</p><p>The appropriate category depends on the organization’s definitions and the purpose of the classification.</p><p>We can provide short descriptions of the available categories to reduce this ambiguity.</p><pre>Use the following category definitions:</pre><pre>Access: Problems involving authentication,<br>accounts, passwords, or permissions.</pre><pre>Hardware: Problems involving physical devices,<br>peripherals, or equipment failures.</pre><pre>Software: Problems involving installed applications,<br>software behavior, or application errors.</pre><pre>Network: Problems involving internet access,<br>Wi-Fi, VPN, or network connectivity.</pre><p>With this additional context, the model has a clearer basis for evaluating the request.</p><p>Notice that we have not made the prompt unnecessarily elaborate. The definitions are concise and relevant to the decision being made. Adding unrelated information about the organization’s history, infrastructure, or internal teams would not necessarily improve classification.</p><p>Effective context management is about supplying information that helps the model perform the intended task, not maximizing the amount of material included in the prompt.</p><p>This distinction becomes increasingly important when applications retrieve information from documents or databases. Additional context may improve performance, but irrelevant, conflicting, or outdated information can introduce new opportunities for error.</p><h3>Define Constraints and Uncertainty</h3><p>A model may produce an answer even when the available information is insufficient to make a reliable determination. For classification tasks, this creates an important requirement: deciding how the application should handle ambiguity.</p><p>We can introduce a review indicator rather than requiring every result to be treated as definitive.</p><pre>Base the classification only on the information<br>provided in the support request.</pre><pre>Do not invent missing details.</pre><pre>If the request is ambiguous, select the most<br>plausible category and set requires_review to true.</pre><pre>If the category is clear, set requires_review to false.</pre><p>These instructions establish a more useful behavior for uncertain cases. The model can still provide a tentative classification, but it must indicate when the result deserves additional attention.</p><p>This does not guarantee that every ambiguous request will be recognized correctly. Language models can misjudge uncertainty, and an instruction to avoid inventing information does not independently prevent every unsupported inference.</p><p>Nevertheless, defining the expected behavior gives the application a clearer specification and establishes something that can be tested.</p><p>In a production environment, a review indicator generated by the model should not be treated as a complete quality-control mechanism. Additional validation, application rules, or human review may be appropriate depending on the consequences of an incorrect classification.</p><h3>Specify What the Output Should Look Like</h3><p>A useful result must often be consumed by software rather than read only by a person.</p><p>If an application expects a category, a short explanation, and a review flag, receiving an unrestricted paragraph introduces unnecessary processing and ambiguity.</p><p>We can define a structured output format using JSON.</p><pre>Return a valid JSON object containing<br>exactly these fields:</pre><pre>category: One of Access, Hardware, Software, Network</pre><pre>reason: A brief explanation of the classification</pre><pre>requires_review: A boolean indicating whether<br>the request needs additional review</pre><pre>Do not include Markdown formatting or<br>additional commentary.</pre><p>For the example involving the new laptop, an expected response might resemble:</p><pre>{<br>  &quot;category&quot;: &quot;Access&quot;,<br>  &quot;reason&quot;: &quot;The user cannot authenticate on the new laptop, although the credentials work on another device.&quot;,<br>  &quot;requires_review&quot;: false<br>}</pre><p>The structured result is easier for an application to inspect and process. It also allows validation rules to confirm whether the category belongs to the supported set and whether the review indicator is a Boolean value.</p><p>However, requesting JSON through a prompt does not guarantee that every response will conform to the required schema. Applications should validate generated output and handle cases where required fields are missing or incorrectly formatted.</p><p>Where supported, model APIs may provide structured-output or schema-constrained generation capabilities that offer stronger formatting guarantees than prompt instructions alone.</p><p>The underlying principle is that prompt engineering can define the expected behavior, but application engineering remains responsible for verifying that the result satisfies the necessary requirements.</p><h3>Putting Everything Together</h3><p>We can now combine the objective, category definitions, constraints, and output requirements into a single reusable prompt.</p><pre>You are an assistant responsible for classifying<br>incoming IT support requests.</pre><pre>TASK<br>Classify the supplied request into exactly one<br>of these categories:</pre><pre>- Access: Authentication, accounts, passwords,<br>  or permissions.<br>- Hardware: Physical devices, peripherals,<br>  or equipment failures.<br>- Software: Installed applications, software<br>  behavior, or application errors.<br>- Network: Internet, Wi-Fi, VPN, or network<br>  connectivity.</pre><pre>RULES<br>- Base the classification only on the supplied request.<br>- Do not invent missing information.<br>- Select the category that best matches the<br>  primary reported issue.<br>- If the request is ambiguous, select the most<br>  plausible category and set requires_review to true.<br>- Otherwise, set requires_review to false.</pre><pre>OUTPUT<br>Return only a valid JSON object with these fields:</pre><pre>{<br>  &quot;category&quot;: &quot;Access | Hardware | Software | Network&quot;,<br>  &quot;reason&quot;: &quot;Brief explanation&quot;,<br>  &quot;requires_review&quot;: false<br>}</pre><pre>The category must be one of the four defined values.<br>Use a JSON boolean for requires_review.<br>Do not add Markdown or extra commentary.</pre><pre>SUPPORT REQUEST<br>&lt;request&gt;<br>[Insert the support request here]<br>&lt;/request&gt;</pre><p>This prompt is longer than the original one-line instruction, but each additional part serves a specific purpose. The task establishes the objective, the definitions provide decision context, the rules constrain behavior, and the output section establishes the format expected by the consuming application.</p><p>The request is also separated from the instructions through a clearly identified input section. This distinction helps communicate that the support ticket is data to classify rather than an additional source of instructions.</p><p>For an actual application, the request should be passed into the template programmatically. Untrusted input must still be handled appropriately, particularly if it contains text intended to manipulate the model’s behavior.</p><h3>Test the Prompt Instead of Assuming It Works</h3><p>A prompt that performs well on one example may behave differently when the wording or complexity of the input changes. This is why testing should be part of prompt engineering rather than an activity reserved exclusively for production software.</p><p>Consider three fictional support requests:</p><p><strong>Request A:</strong> “My VPN keeps disconnecting when I work from home.”</p><p>The expected classification is Network, with no review required if the request provides sufficient detail.</p><p><strong>Request B:</strong> “My monitor does not turn on, even after reconnecting the power cable.”</p><p>The expected classification is Hardware, again without an obvious need for additional review.</p><p><strong>Request C:</strong> “My computer isn’t working properly, and I can’t get my work done.”</p><p>The third request is less specific. A model may attempt a tentative classification, but the review indicator should be true because the reported symptoms do not provide enough information for a reliable determination.</p><p>These examples provide a starting point for evaluating whether the prompt behaves as intended.</p><p>A more complete evaluation would include requests involving overlapping categories, vague descriptions, spelling errors, and unusual terminology. The same examples should be used when comparing prompt revisions so that improvements can be assessed under reasonably consistent conditions.</p><p>For repeatable applications, it is also useful to record the model, configuration, and prompt version associated with each evaluation. This helps distinguish changes caused by prompt revisions from those introduced by a different model or generation configuration.</p><p>The goal is not to create a prompt that performs perfectly on a small collection of carefully selected examples. It is to understand where the instructions produce dependable behavior and where additional information, application logic, or a different technical approach may be needed.</p><h3>Prompt Engineering as a Form of Specification</h3><p>The most useful way to think about prompt engineering is not as a collection of phrases that persuade a model to perform better. It is as the process of defining what a system should accomplish and establishing expectations for how it should respond.</p><p>Clear instructions reduce ambiguity, relevant context supports better decisions, constraints establish boundaries, and structured outputs make responses easier to process. Evaluation then provides evidence about whether those decisions actually improve performance.</p><p>These principles apply whether someone is using an AI assistant interactively or building an application that processes thousands of requests.</p><p>They also reveal the limits of prompting. A prompt cannot guarantee factual correctness, enforce access permissions, replace input validation, or establish that a model’s output is appropriate for every situation. Those responsibilities belong to the broader system and the people responsible for designing and operating it.</p><p>As AI capabilities become increasingly accessible, the difference between a useful demonstration and a dependable application often depends on how deliberately the interaction has been specified, tested, and integrated.</p><p>A better prompt may begin with clearer wording, but reliable prompt engineering requires something more substantial: understanding the task, defining acceptable behavior, and evaluating the evidence that the system performs as intended.</p><h3>Further Reading</h3><p><a href="https://platform.openai.com/docs/guides/prompt-engineering"><strong>OpenAI — Prompt Engineering</strong></a></p><p>Guidance on writing instructions, providing context, and improving model responses through structured prompting.</p><p><a href="https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/overview"><strong>Anthropic — Prompt Engineering Overview</strong></a></p><p>Practical recommendations for defining success criteria, clarifying instructions, and evaluating prompting approaches.</p><p><a href="https://cloud.google.com/vertex-ai/generative-ai/docs/learn/prompts/prompt-design-strategies"><strong>Google Cloud — Prompt Design Strategies</strong></a></p><p>Guidance on prompt structure, instructions, examples, constraints, and repeatable prompt design.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3474e5297ff2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Mathematics of Conversing]]></title>
            <link>https://medium.com/@bryan.pesquera/the-mathematics-of-conversing-dd142c19667f?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/dd142c19667f</guid>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Wed, 11 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-11T15:11:01.760Z</atom:updated>
            <content:encoded><![CDATA[<p><em>How numbers, probabilities, and patterns became remarkably good at sounding human.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*BqrkJ86EbIh1BZBXx2Ly8Q.png" /></figure><p>There is a particular moment in an AI conversation that I find more interesting than the first answer. It happens when I push back. I say that an explanation missed the point, introduce a new constraint, or ask the system to reconsider something from another perspective. The next response can feel less like a result being returned and more like a conversation finding its direction.</p><p>That experience raises a question worth sitting with. How does a system built from numerical calculations produce language that feels responsive, coherent, and occasionally insightful? How does it move from predicting pieces of text to offering something that seems like an idea?</p><p>Calling it a digital mind moves too quickly toward a conclusion. Calling it “just autocomplete” moves too quickly in the other direction. I would rather understand what happens between the question and the answer.</p><p>To do that, we need to look inside a particular kind of system: an autoregressive, transformer-based language model. That is a technical name for a model that generates text by repeatedly producing a continuation from the information available to it. It is not a description of every kind of artificial intelligence, but it gives us a useful starting point for understanding conversational AI. <a href="https://arxiv.org/abs/2005.14165">arXiv</a></p><h3>Before there is a sentence, there are numbers</h3><p>Imagine sending a model this message: “I left the keys in the blue drawer, not the red one. Where should I look?”</p><p>For a person, this is an ordinary question with an obvious answer. For the model, the text first has to be converted into something its mathematical operations can process. A tokenizer divides it into units called <em>tokens</em>, which might be whole words, fragments of words, punctuation, or combinations that include spaces. Each token receives a numerical identifier. The exact divisions depend on the tokenizer. <a href="https://huggingface.co/learn/llm-course/en/chapter2/4">Hugging Face</a></p><p>Those identifiers are labels, not meanings. Giving “blue” a particular number does not explain what blue is, any more than assigning a book a catalog number explains its contents.</p><p>The next step is an <em>embedding</em>: a learned list of numerical values representing each token. Mathematically, this list is a vector. The model also incorporates information about position, because a sentence is not simply a collection of words. “The dog chased the person” and “The person chased the dog” contain the same words but describe different events. <a href="https://nlp.seas.harvard.edu/annotated-transformer/">Harvard NLP</a></p><p>These initial vectors are starting points, not complete definitions. As they pass through the network, their representations are transformed using the surrounding context. The task is not merely to recognize “keys,” “blue,” and “drawer” separately. A useful answer needs to preserve the relationship between them, including the fact that “not the red one” rules out a competing location. The transformer’s attention mechanism provides a way for information from different positions to interact. <a href="https://arxiv.org/html/1706.03762v7">arXiv</a></p><p>The sentence has not become meaningful because we replaced its words with numbers. It has become something a learned mathematical system can work on.</p><h3>How the mathematics learns</h3><p>The word <em>learned</em> is doing considerable work here. Where do these useful numerical relationships come from?</p><p>Inside a neural network are adjustable parameters, often called weights. These numbers influence how information is transformed as it passes through the model. In next-token pretraining, the network uses preceding text to predict the token that actually follows it in a training example. The text itself supplies the target; a person does not need to write a separate explanation of the grammar or meaning of every sentence. <a href="https://huggingface.co/learn/llm-course/en/chapter7/6">Hugging Face</a></p><p>The training process measures how much probability the model assigned to that actual next token. Assigning it very little probability produces a larger penalty, called a <em>loss</em>. The objective is to adjust the model so that, across many examples, it becomes better at these predictions. <a href="https://huggingface.co/learn/llm-course/en/chapter7/6">Hugging Face</a></p><p>Backpropagation uses calculus to work out how changes to the parameters would affect the loss. An optimization algorithm then uses that information to adjust the weights. Repeating this process across batches of examples gradually changes the network’s behavior. “Learning,” in this setting, is not a metaphor for someone inside the computer studying a book. It is a specific process of numerical adjustment. <a href="https://docs.pytorch.org/tutorials/beginner/basics/autogradqs_tutorial.html">PyTorch Documentation</a></p><p>It would also be a mistake to conclude that this process excludes memorization. Researchers have demonstrated that language models can reproduce passages from their training data verbatim. Prediction and memorization are not opposites; a model can generalize in some situations and reproduce learned material in others. <a href="https://arxiv.org/abs/2012.07805">arXiv</a></p><p>The important distinction is that generating an answer does not require someone to have written that exact answer in advance. The training process changes a system of numerical relationships that can be applied to new inputs, rather than simply building a menu of responses.</p><h3>Attention connects the pieces</h3><p>The transformer gets much of its flexibility from <em>attention</em>. Despite the human-sounding name, this is a mathematical operation, not an assertion that the system experiences concentration.</p><p>Attention computes relationships between numerical representations at different positions. In a standard formulation, it creates vectors called queries, keys, and values. Numerical comparisons between queries and keys determine how strongly to combine information from the values. Multiple attention heads perform different learned combinations in parallel. <a href="https://arxiv.org/html/1706.03762v7">arXiv</a></p><p>In our drawer example, a successful answer must connect the question about where to look with the earlier statement about the keys. Simply noticing that both “blue” and “red” appear would not be enough. The relationship expressed by the sentence matters more than the presence of either word.</p><p>Attention is only part of the network. Other components, including feed-forward layers, further transform the representations. These operations repeat across layers, allowing the computation to build on information produced earlier in the network. The result is substantially more involved than counting which word most often appears beside another. <a href="https://nlp.seas.harvard.edu/annotated-transformer/">Harvard NLP</a></p><p>This is why I find “just predicting the next word” an unsatisfying explanation. It names an objective while leaving out the machinery required to pursue it. Describing the final output step does not tell us how much computation can happen before that step.</p><h3>How a probability becomes a sentence</h3><p>Eventually, the model has to produce text. The central question can be written compactly:</p><p>\[ P(\text{next token}\mid\text{context}) \]</p><p>Read this as: “Given the context, what probability does the model assign to each possible next token?” The vertical line means “given.” The context includes the input and whatever has already been generated.</p><p>The network produces numerical scores called <em>logits</em>. A function called <em>softmax</em> converts those scores into a probability distribution: a set of nonnegative probabilities that add up to one. This gives the generation process a distribution over possible next tokens, rather than a single inevitable answer. <a href="https://docs.mistral.ai/resources/cookbooks/concept-deep-dive-sampling-temperature">Mistral AI</a></p><p>Suppose, purely as an illustration, that a model has begun answering our question with “Look in the” and its next-token distribution assigns 85 percent to a token representing “blue,” 5 percent to “red,” and the remaining 10 percent to other possibilities. Those are invented numbers, not measurements from a real model. Their purpose is to show what the distribution represents: alternatives with different weights.</p><p>One generation strategy selects the highest-probability token. Another samples from the distribution, making higher-probability tokens more likely without making them certain. The chosen token is added to the response, and generation continues using the updated context. This is one reason the same prompt can produce different wording on different runs. <a href="https://huggingface.co/docs/transformers/generation_strategies">Hugging Face</a></p><p>A setting called <em>temperature</em> can change how concentrated that distribution is. Lower temperatures sharpen the preference for higher-scoring tokens; higher temperatures flatten the distribution and give lower-scoring alternatives more opportunity. Temperature does not add knowledge or verify facts. It changes how the model’s scores influence selection. <a href="https://docs.mistral.ai/resources/cookbooks/concept-deep-dive-sampling-temperature">Mistral AI</a></p><p>That distinction matters. A setting that produces more varied language is not automatically producing better ideas, and a setting that produces more predictable language is not automatically producing truth.</p><p>The paragraph we eventually read is therefore the result of many conditional steps. Each new piece becomes part of what the model has available for the next. But sequential output does not, by itself, tell us whether the underlying computation is shallow or sophisticated. Some reasoning models are also trained to generate intermediate reasoning before delivering a final answer, using additional computation to work through a problem. <a href="https://arxiv.org/html/2501.12948v1">arXiv</a></p><h3>Why it answers instead of merely continuing</h3><p>A model trained to continue text is not automatically a good assistant.</p><p>Given a question, continuing the text might mean writing an answer, inventing the next line of a fictional dialogue, or producing another question in a list. Learning the patterns of written language and learning to respond helpfully to someone are related goals, but they are not identical.</p><p>This is where <em>post-training</em> comes in. One established approach uses demonstrations of desirable responses to teach instruction-following. Another uses comparisons between candidate answers to guide further training toward preferred behavior. The InstructGPT research demonstrated that such training could make responses more useful to people while also improving measured truthfulness, although mistakes remained. <a href="https://arxiv.org/abs/2203.02155">arXiv</a></p><p>Other training approaches use outcomes that can be checked more directly, such as whether a mathematical answer is correct or generated code passes tests. Work on reasoning models has shown that reinforcement learning with these kinds of signals can improve performance on verifiable tasks. <a href="https://arxiv.org/html/2501.12948v1">arXiv</a></p><p>So the assistant’s behavior is not explained by raw text prediction alone. Its responses reflect both the capabilities acquired during earlier training and the objectives used to shape how those capabilities are expressed.</p><p>I find this useful to remember when an answer sounds particularly reassuring, agreeable, or polished. Those qualities are part of the behavior being produced. They should not be confused with independent evidence that the answer is right.</p><h3>Following a conversation is not the same as permanently learning it</h3><p>There is another distinction hidden inside a natural exchange: the difference between changing the context and changing the model.</p><p>During ordinary inference — the process of using a trained model to generate an answer — the weights generally remain fixed. A model can respond differently because the information supplied to it has changed, without any new training taking place. The GPT-3 research demonstrated this clearly through tasks specified using instructions and examples in the input, without updating the model’s parameters. <a href="https://arxiv.org/abs/2005.14165">arXiv</a></p><p>Return to the keys. Suppose I now write, “Actually, I moved them to the red drawer.” An appropriate next answer should reflect that update. The information needed to change the answer is present in the conversation; the model does not need to undergo retraining to use it.</p><p>This is a narrower claim than saying it has permanently learned something about my home. In-context adaptation concerns the information available for the present computation. It should not be mistaken for a guarantee that the system will retain the detail across future interactions.</p><p>The distinction is easy to overlook because, from my side of the screen, both situations can feel like being remembered.</p><h3>Why a convincing answer can still be wrong</h3><p>The probability in our equation is a probability over possible next tokens. It is not a certificate that the resulting claim is true.</p><p>That difference is central to understanding hallucinations: generated claims that are false or unsupported. A model can learn patterns that help it produce accurate answers, but it can also reproduce misconceptions. The TruthfulQA research specifically examined this problem, showing that models could generate false answers resembling familiar human misconceptions. <a href="https://aclanthology.org/2022.acl-long.229/">ACL Anthology</a></p><p>Imagine asking for the source of an obscure quotation. An answer could have every visible feature of a respectable citation: a plausible author, a suitably academic title, a publication date, and confident surrounding prose. None of those features, individually or together, establishes that the cited work exists or contains the quotation.</p><p>There is a basic separation here between producing the form of an explanation and establishing its evidential foundation. I do not need to dismiss the explanation to recognize that separation. I need to check the parts on which my conclusion depends.</p><p>Retrieval-augmented generation addresses part of this problem by bringing external material into the process. Instead of relying only on information encoded in the model’s parameters, a system can retrieve relevant documents and use them when generating a response. Research on this approach found improvements in factuality compared with a model-only baseline. <a href="https://arxiv.org/abs/2005.11401">arXiv</a></p><p>But providing evidence and using it correctly remain different requirements. As a reader, I still want to know whether the source supports the claim, not merely whether a source appears beside it.</p><p>The standard I try to maintain is simple: fluency can make an explanation easier to follow. It should not make the explanation exempt from scrutiny.</p><h3>Where a new idea can come from</h3><p>The question becomes more interesting when the output is not a factual answer but a suggestion.</p><p>Imagine asking for a better way to organize software maintenance. A model might propose treating incoming bug reports like a triage queue, prioritizing urgency and impact rather than the order in which reports arrived. That could be a useful reframing for the person asking. It would not mean the system invented triage, or that nobody had applied it to software before.</p><p>There are several different achievements we might casually call creativity. A sentence can have unfamiliar wording. A connection can be new to the reader. A proposed design can be useful in a particular situation. A discovery can be genuinely new to a field. Those are not interchangeable claims.</p><p>Nor does the fact that a system learned from existing material logically restrict it to reproducing existing results. Learning a method or relationship can enable new applications. Whether a particular output actually achieves that has to be established, not assumed from how surprising it sounds.</p><p>There are concrete research examples of this distinction. FunSearch paired a language model that proposed programs with a systematic evaluator and a search process. The resulting system produced new mathematical results. The achievement depended on more than generating a promising-looking answer: candidates were evaluated, and successful ones informed further search. <a href="https://doi.org/10.1038/s41586-023-06924-6?utm_source=chatgpt.com">DOI</a></p><p>That is a more useful picture of machine-generated ideas than either extreme of the debate. The model need not be dismissed as incapable of novelty, nor treated as an oracle whose suggestions validate themselves. Generation can propose possibilities. Evaluation determines which possibilities deserve to survive.</p><p>For my purposes, that is enough to make the exchange valuable. A suggestion does not have to arrive through a human-like experience of inspiration to become something I can examine, improve, or use.</p><h3>What remains on our side of the conversation</h3><p>Understanding the mechanism does not make the experience less interesting to me. It changes what I expect from it.</p><p>I can appreciate a clear explanation without treating clarity as proof. I can explore an unfamiliar suggestion without assuming it is unprecedented. I can notice that a response feels attentive without drawing conclusions about an inner experience behind the words.</p><p>When I say a model “understands,” I would rather be specific about the behavior I mean. Did it track a constraint? Did it apply a concept correctly in a new situation? Did its explanation survive being checked? Those questions give me something to investigate. A broad impression of intelligence gives me much less.</p><p>The value of a conversation also does not reside entirely in whoever — or whatever — produces the next sentence. It can lie in what happens to my own thinking as I read it. An explanation might reveal a gap in my knowledge. An objection might force me to sharpen an argument. An imperfect suggestion might become the starting point for a better one.</p><p>The mathematics helps explain how the response becomes possible. It does not decide what the response deserves from us. That is still our part of the conversation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dd142c19667f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Practical Guide to Learning Enterprise AI with Free IBM Courses and Badges]]></title>
            <link>https://medium.com/@bryan.pesquera/a-practical-guide-to-learning-enterprise-ai-with-free-ibm-courses-and-badges-dcd1ea9a290b?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/dcd1ea9a290b</guid>
            <category><![CDATA[online-learning]]></category>
            <category><![CDATA[ibm]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[professional-development]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-09T15:11:01.664Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Publicly accessible learning resources for building a foundation in AI, data, cloud, security, and the human side of technical problem-solving.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YHXnH_ave6XrPnH7bkbk-A.png" /><figcaption>Building practical enterprise AI expertise through continuous learning, hands-on experience, and publicly accessible IBM courses and digital credentials spanning artificial intelligence, data, cloud computing, cybersecurity, and design thinking.</figcaption></figure><p>A useful learning path for enterprise AI should extend beyond understanding what a model can generate. It should also help someone ask better questions about the information an application uses, the environment in which it operates, the controls it needs, and the people it is intended to support. Those questions provide a more practical starting point than trying to learn every new framework or collecting courses without a clear relationship between them.</p><p>For someone approaching the subject, I would organize learning around those underlying responsibilities. Begin with AI concepts, develop an understanding of data, explore the infrastructure and security considerations surrounding applications, and connect the technical work to an identifiable user need. This creates a foundation that can support later specialization without requiring every learner to follow the same career path.</p><p><a href="https://skillsbuild.org/">IBM SkillsBuild</a> offers a useful place to begin because its learning is free, and selected learning paths lead to digital credentials. The resources below focus on publicly accessible options rather than employee-only training, with additional courses for exploring prompting and AI agents. The intention is to provide a manageable route into the subject, not an exhaustive catalog of everything IBM offers.</p><h3>Understanding What Is Available to the Public</h3><p>A publicly visible badge is not necessarily a badge that anyone can earn. Some credentials are associated with partner organizations, structured programs, or particular learning experiences. Before beginning, it is worth checking the earning criteria rather than relying solely on a badge’s title or description. The <a href="https://skillsbuild.org/digital-credentials">IBM SkillsBuild digital credential catalog</a> identifies the intended audience, while individual credential pages provide more specific completion requirements.</p><p>The five SkillsBuild badges highlighted here have public learning routes, and IBM lists them as available to all learners. The adult routes require registration rather than IBM employment. The durations mentioned below are the estimates in IBM’s catalog, so I would use them for planning rather than treat them as deadlines or guarantees about how quickly someone should finish.</p><h3>Start with Artificial Intelligence Fundamentals</h3><p>The <a href="https://www.credly.com/org/ibm-skillsbuild/badge/artificial-intelligence-fundamentals">Artificial Intelligence Fundamentals credential</a> provides a broad introduction to machine learning, deep learning, neural networks, natural language processing, computer vision, and AI ethics. IBM estimates <strong>10 or more hours</strong> for the learning path. The credential is free, and earning it requires completing the prescribed courses, passing the graded quizzes and final assessments, and completing the practice simulations. The credential page includes a direct route for registered adult learners.</p><p>I would start here when the terminology is familiar but the relationships between concepts are still unclear. Being able to use an AI application is different from understanding which kind of capability it provides, what information supports it, and how its output should be evaluated. A foundational course is an opportunity to establish that vocabulary before moving into a particular development framework or product.</p><p>To make the learning more concrete, choose one hypothetical organizational problem and describe it without selecting a technology first. An employee might need to locate current procedures, a service team might need to categorize incoming requests, or an analyst might need help reviewing a collection of documents. Explain the desired outcome, identify where AI might contribute, and describe which parts could be handled through conventional software. That exercise gives the concepts somewhere to go beyond a quiz response.</p><h3>Develop an Understanding of the Data</h3><p>The <a href="https://www.credly.com/org/ibm-skillsbuild/badge/data-fundamentals">Data Fundamentals credential</a> covers data analytics concepts, data science methodologies, and tools used in the data ecosystem. It includes a conceptual introduction to cleaning, refining, and visualizing data using IBM Watson Studio. IBM estimates <strong>seven hours</strong>, and the free credential requires completing the prescribed courses, assessments, and practice simulations.</p><p>I would include data literacy early in an enterprise AI learning path because it encourages scrutiny of the material an application is expected to use. For a document assistant, that means asking which sources are authoritative, whether older versions should remain searchable, and how a reader could verify an answer. For an application working with structured records, it means examining what each field represents and whether the available information actually supports the proposed task.</p><p>A useful companion exercise is to examine a small public dataset and write a brief assessment of its suitability for a particular purpose. Look for missing values, inconsistent labels, unclear definitions, and assumptions that would need to be resolved before relying on the data. The objective does not need to be an elaborate analysis. A clear explanation of what the information can and cannot support is already a meaningful technical deliverable.</p><h3>Add Practical Experience with Prompting</h3><p>For a more direct introduction to interacting with generative models, <a href="https://cognitiveclass.ai/courses/prompt-engineering-for-everyone">Prompt Engineering for Everyone</a> is a free course offered by IBM Skills Network through Cognitive Class. Its course page lists <strong>five hours</strong> of estimated effort, no technical prerequisites, and a completion certificate. The syllabus includes prompting patterns, exercises, quizzes, and an introduction to watsonx Prompt Lab. This is a supplementary course rather than one of the five SkillsBuild badges in this guide.</p><p>I would approach prompting as an exercise in defining a task and evaluating the result, rather than searching for a phrase that makes every response useful. Choose a small activity, such as summarizing fictional support requests, and specify what a satisfactory output should contain. The summary might need to identify the reported issue, distinguish confirmed information from assumptions, and preserve details that someone would need for follow-up work.</p><p>Then compare a few versions of the instructions against the same examples. Record what changed, where the output improved, and where it still failed to meet the requirements. This produces a small evaluation exercise alongside the course and makes it easier to explain why one approach is preferable to another. The result is more useful than a collection of prompts whose performance has never been examined.</p><h3>Learn the Infrastructure Around the Application</h3><p>The <a href="https://www.credly.com/org/ibm-skillsbuild/badge/cloud-computing-fundamentals">Cloud Computing Fundamentals credential</a> introduces cloud services, deployment models, virtualization, orchestration, and cloud security. It also includes conceptual learning about containers and web application deployment, with practice simulations included in the earning requirements. IBM estimates <strong>10 hours</strong>, and the badge is free for registered SkillsBuild learners who complete the required learning and assessments.</p><p>For this learning path, I would use the cloud material to connect an AI capability to the application that surrounds it. Take the hypothetical problem from the first course and identify where the user interface, application logic, information sources, and model access would sit. The exercise should reveal what the system depends on rather than attempt to produce an elaborate architecture.</p><p>A simple drawing and a short explanation are sufficient. Describe which components would need to communicate, what information would move between them, and what should happen when one becomes unavailable. Readers who already work comfortably with cloud infrastructure may not need another foundational credential, but the exercise can still help distinguish existing knowledge from areas that need further study.</p><h3>Include Security in the Learning Path</h3><p>The <a href="https://www.credly.com/org/ibm-skillsbuild/badge/cybersecurity-fundamentals">Cybersecurity Fundamentals credential</a> covers threats, attacks, social engineering, cryptography, and approaches to preventing, detecting, and responding to security incidents. IBM’s catalog estimates <strong>7.5 hours</strong>. The credential is free, and its earning criteria require completion of the course and a score of at least <strong>80 percent</strong> on the end-of-course assessment.</p><p>I would use this material to review the proposed application from the perspective of someone responsible for protecting its information and operations. Who should be allowed to use it? Which information should remain unavailable to particular users? What credentials would the application need, and what actions should remain outside its authority? These questions keep the exercise tied to a real design rather than turning security into a collection of definitions to memorize.</p><p>For a small practice project, write a short security review alongside the architecture. Identify the information involved, the users who need access, and the actions that could have consequences beyond the interface. Then describe a few situations the application should reject or escalate. This is not intended to substitute for a professional assessment; it is a way to practice recognizing boundaries before a design becomes more complicated.</p><h3>Connect the Technology to a User Need</h3><p>The <a href="https://www.ibm.com/training/enterprise-design-thinking">Enterprise Design Thinking Practitioner badge</a> adds a different dimension to the learning path. IBM offers its Practitioner learning experience through SkillsBuild and explicitly states that the badge can be earned for free. The credential catalog estimates <strong>three hours</strong> and describes learning around collaboration, design research, prototyping, and communicating ideas to align a team around human-centered problems.</p><p>I would include this badge because a technical learning plan should also create opportunities to question whether the proposed solution is worth building. It is easy to describe what an application will do without explaining why someone would use it or how it would fit into their work. For the hypothetical project, identify a specific user, describe the difficulty they experience, and explain what a better outcome would look like from their perspective.</p><p>That description can become the basis for a simple prototype or workflow sketch. Instead of asking whether the design looks impressive, ask whether the person can understand what to do, verify the result, and continue their work when the application cannot help. Those questions connect the technical exercises to a more complete picture of the intended experience.</p><p>The credential also provides a useful reason to revisit earlier assumptions. A feature that seemed essential during an architecture exercise may turn out to contribute little to the user’s actual task. Conversely, a modest capability such as showing the source of an answer or allowing a correction may deserve more attention than the most technically ambitious part of the design.</p><h3>Explore AI Agents as a Follow-On Topic</h3><p>After the foundations, <a href="https://cognitiveclass.ai/courses/introduction-to-agentic-ai">Introduction to Agentic AI</a> offers an additional free learning option through Cognitive Class. The IBM Skills Network course lists <strong>three hours</strong> of estimated effort and covers agent concepts, tool use, the Model Context Protocol, retrieval-augmented generation, orchestration, and multi-agent systems. Its course page explicitly states that <strong>no certificate is offered</strong>, so I would use it for the learning rather than expect another credential.</p><p>This is a suitable point to revisit the difference between an application that provides information and one that changes something in a connected system. Extend the hypothetical project with one proposed action, such as preparing an internal request or updating a low-risk status. Describe what information the action requires, who should authorize it, and how the application would confirm that it succeeded.</p><p>I would keep that exercise deliberately narrow. There is no need to begin by designing an agent that coordinates an entire department. One clearly defined action provides enough material to examine permissions, validation, failure handling, and human review while keeping the problem understandable.</p><h3>Turn the Learning into a Small Body of Work</h3><p>The exercises above can become parts of one project rather than seven unrelated assignments. A document assistant built around public information, for example, could be accompanied by a problem statement, an assessment of its sources, a few prompt comparisons, a basic architecture, and a short review of access and security boundaries. The final deliverable does not need to be a production application. It needs to show a coherent relationship between the problem, the proposed design, and the evidence used to evaluate it.</p><p>For someone new to the subject, I would begin with Artificial Intelligence Fundamentals and Enterprise Design Thinking Practitioner. Together, they provide a starting point for discussing both the technology and the problem it should address. Data Fundamentals can then help examine the information involved, followed by prompting practice and the infrastructure or security topics that are least familiar.</p><p>An experienced developer can use the same resources more selectively. There is little value in repeating foundational material solely to make the collection larger. A better approach is to identify a specific gap, complete the relevant learning, and apply it to a task that exposes whether the new understanding is useful. The sequence should support the learner’s development rather than become another checklist.</p><h3>Make the Credential Part of the Evidence</h3><p><a href="https://skillsbuild.org/digital-credentials">IBM SkillsBuild uses Credly to issue and share its digital credentials</a>. After completing an eligible learning activity and meeting its requirements, learners can accept the credential through Credly and share its verification page. That page provides a more informative record than a badge image alone because it identifies the credential and its earning criteria.</p><p>When presenting the learning professionally, I would pair that verification with a brief explanation of what was practiced. A small project, an evaluation write-up, or an architecture explanation gives the reader something concrete to discuss alongside the credential. It also helps keep the description proportionate: completing foundational learning is a useful achievement, while designing and operating a dependable system involves further experience.</p><p>The value of this path is not that it produces the largest possible number of badges. It offers accessible entry points into several responsibilities surrounding enterprise AI and creates opportunities to connect them through practical work. Someone can begin with a free course, develop a clearer understanding of a problem, and gradually build evidence of how they approach technical decisions.</p><p>That is the approach I would encourage: use the credentials to structure learning, use small projects to apply it, and let the questions that emerge guide the next subject to study.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=dcd1ea9a290b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Rise of the AI Forward Deployed Engineer: What the Role Is and Why It Matters]]></title>
            <link>https://medium.com/@bryan.pesquera/the-rise-of-the-ai-forward-deployed-engineer-what-the-role-is-and-why-it-matters-d1dae8f7616a?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/d1dae8f7616a</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[forward-deployed-engineer]]></category>
            <category><![CDATA[enterprise-ai]]></category>
            <category><![CDATA[career-development]]></category>
            <category><![CDATA[technology]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-06T15:11:01.808Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Exploring the origins of forward-deployed engineering, its evolution in the AI industry, and why organizations are bringing engineers closer to the problems they’re trying to solve.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kP0lbDnEoOOj6arKo22vOg.png" /><figcaption>Bridging engineering expertise and operational needs to turn emerging AI capabilities into practical, mission-aligned solutions.</figcaption></figure><p>Artificial intelligence is changing how organizations approach software development, automation, and digital transformation. As increasingly capable models become accessible through APIs, development frameworks, and enterprise applications, the technical barriers to experimenting with AI have decreased considerably. Organizations can now demonstrate capabilities that would have required substantially more specialized development only a few years ago, creating new opportunities to improve existing processes and introduce more intelligent software systems.</p><p>However, demonstrating what a technology can accomplish is different from incorporating it into an operational environment. Enterprise systems must interact with established applications, organizational data, identity services, and business processes that were rarely designed with modern AI capabilities in mind. Security, governance, reliability, and maintenance requirements also influence whether a proposed solution can progress beyond experimentation.</p><p>These conditions have contributed to growing attention around a particular engineering role: the <strong>Forward Deployed Engineer</strong>, commonly abbreviated as FDE. As artificial intelligence becomes increasingly important to enterprise technology strategies, the term <em>AI Forward Deployed Engineer</em> is being used to describe engineers who work directly with organizations to evaluate, develop, and operationalize AI-enabled solutions.</p><p>Although the title may be unfamiliar outside certain areas of the technology industry, the underlying concept is not entirely new. Forward-deployed engineering brings technical practitioners closer to the organizations, users, and operational environments where software is intended to create value. Rather than treating solution design, implementation, and stakeholder engagement as entirely separate responsibilities, the role combines elements of these activities within a more integrated engineering approach.</p><p>The expansion of enterprise AI has renewed interest in this model. Organizations increasingly recognize that access to capable models and development platforms represents only one component of successful adoption. Translating those capabilities into dependable solutions requires engineers who understand both the technology and the conditions under which it must operate.</p><p>Understanding the role therefore requires examining its origins, how its responsibilities differ from established engineering positions, and why it is becoming increasingly relevant to organizations pursuing AI initiatives.</p><h3>The Origins of Forward-Deployed Engineering</h3><p>The practice of placing engineers close to customers and operational environments predates modern artificial intelligence. Organizations have long relied on field engineers, systems integrators, technical consultants, and specialized delivery teams to implement technology within complex environments. These roles emerged from a practical reality: software that performs well under controlled development conditions may require substantial adaptation before it can operate effectively within an established organization.</p><p>As enterprise software became more sophisticated, certain technology organizations began formalizing a distinction between engineers responsible for developing reusable platforms and those responsible for applying those platforms to specific customer environments. The latter increasingly became associated with the forward-deployed engineering model, particularly in technically demanding implementations involving data integration, specialized applications, and complex operational requirements.</p><p>This distinction reflected an important architectural consideration. A reusable software platform may provide substantial functionality, but the way that functionality must be applied often depends on the environment in which it operates. Data structures, integrations, user requirements, and operational constraints may differ significantly between organizations, even when they adopt the same underlying technology.</p><p>Forward-deployed engineers were positioned to work directly with these conditions, combining software development, integration, troubleshooting, and stakeholder engagement. Rather than focusing exclusively on the capabilities of the underlying product, their responsibilities extended to understanding how those capabilities could be adapted to address a particular organizational problem.</p><p>In some implementations, forward-deployed engineers also contributed improvements, reusable integrations, and technical feedback that informed the development of the broader software platform. This created a relationship between the engineers working directly with customers and the teams responsible for maintaining and extending the technology.</p><p>The model did not introduce an entirely new category of engineering activity. Its significance came from organizing customer-facing technical work into a more explicit engineering discipline, with an emphasis on direct implementation and the delivery of outcomes within real operational environments.</p><p>Over time, forward-deployed engineering became associated with technically demanding enterprise implementations, particularly those where understanding the customer’s systems and operating conditions was as important as understanding the technology being introduced.</p><p>The current interest in AI forward-deployed engineering represents an evolution of this approach rather than a complete departure from its origins.</p><h3>Why Artificial Intelligence Is Accelerating the Evolution of the Role</h3><p>The expansion of generative AI has introduced a similar challenge on a considerably broader scale.</p><p>Foundation models provide flexible capabilities that can support document understanding, software development, natural language interaction, information retrieval, and automated task execution. These capabilities can be incorporated into different applications without requiring organizations to develop their own models from the beginning.</p><p>However, the availability of a general-purpose model does not automatically establish how it should be used within a particular organization.</p><p>An AI assistant intended to answer questions about internal procedures, for example, requires more than access to a language model. The engineering team must determine where authoritative information resides, how that information should be retrieved, which users are permitted to access it, and how the application should behave when sources are incomplete or conflicting.</p><p>An agent capable of performing actions introduces additional considerations. It may need to authenticate against enterprise systems, respect established authorization boundaries, execute workflows, and handle situations where connected services are unavailable or return unexpected results. These responsibilities require an understanding of both the technology and the operational environment in which it will be used.</p><p>Traditional product engineering teams are often responsible for making platforms and services more capable, reliable, and broadly reusable. Customer-facing engineering teams must determine how those capabilities can be applied to specific organizational challenges while accommodating existing infrastructure, operational processes, and technical requirements.</p><p>Forward-deployed engineering provides one way to bring those responsibilities closer together.</p><p>Engineers can work directly with stakeholders to understand the problem, validate technical assumptions, develop integrations, and demonstrate whether a proposed approach can produce a meaningful improvement. Instead of treating the customer’s environment as a collection of requirements to be handed off between teams, the model emphasizes continuous technical engagement throughout the development and validation process.</p><p>This is particularly relevant to AI because many implementation challenges emerge only after a capability is introduced into a realistic environment. Data may be incomplete, existing applications may impose unexpected limitations, or organizational procedures may require additional controls that were not evident during initial discovery.</p><p>The growing interest in forward-deployed engineering reflects a broader recognition that successful AI adoption requires more than access to advanced technology. It requires technical expertise capable of connecting emerging capabilities with established systems, operational responsibilities, and measurable organizational objectives.</p><h3>What an AI Forward Deployed Engineer Actually Does</h3><p>There is no single, universally accepted definition of an AI Forward Deployed Engineer. Responsibilities vary according to the organization, the technologies involved, the engagement model, and whether the work concentrates on early technical validation, production implementation, or longer-term operational support.</p><p>Nevertheless, several responsibilities appear consistently across modern interpretations of the role.</p><p>An AI Forward Deployed Engineer typically works close to the problem being addressed, engaging with technical and business stakeholders to understand the desired outcome and the conditions under which a solution must operate. This may involve examining existing architecture, identifying integration requirements, evaluating available data, and distinguishing between what stakeholders initially request and what the underlying process actually needs.</p><p>The role also maintains a direct engineering component. Depending on the engagement, this may include writing application code, developing integrations, configuring AI systems, implementing automation workflows, or investigating technical limitations that influence feasibility.</p><p>This combination is particularly relevant during the early stages of AI initiatives, when requirements may be incomplete and the technical approach can evolve significantly as stakeholders interact with the developing solution.</p><p>An initial discussion might suggest that an organization needs a conversational assistant. Further investigation may reveal that the more consequential opportunity involves reducing manual system navigation, improving access to authoritative information, or automating a specific portion of an existing workflow.</p><p>In such circumstances, the engineering responsibility is to evaluate the available approaches and determine which technical solution is most appropriate rather than treating the first proposed implementation as a fixed requirement.</p><p>Forward-deployed engineers may also participate in iterative demonstrations and validation activities. These interactions provide opportunities to test assumptions, communicate technical tradeoffs, and identify requirements that are difficult to establish through documentation alone.</p><p>In some organizations, the FDE retains responsibility through production deployment and subsequent optimization. In others, responsibilities may transition to dedicated implementation, platform, or operations teams after a solution has been validated. The title itself does not establish which delivery stages an engineer owns, nor does it guarantee that every engagement follows the same process.</p><p>A defining characteristic is therefore not a particular framework, programming language, or deployment method. It is the combination of technical execution and direct engagement with the operational problem the technology is intended to address.</p><h3>How the Role Differs from Traditional Engineering Positions</h3><p>Forward-deployed engineering shares responsibilities with several established technical disciplines, which can make the position difficult to distinguish from other roles.</p><p>A traditional software engineer may concentrate on developing and maintaining application capabilities, services, and platforms. Their responsibilities can involve substantial architectural reasoning and collaboration, but the work is often organized around a product, codebase, or engineering team rather than a particular customer engagement.</p><p>A solutions architect typically emphasizes system design, integration strategies, technical feasibility, and alignment between business requirements and technology. Many solutions architects also develop prototypes and contribute code, particularly in organizations where architecture and implementation responsibilities overlap.</p><p>Technical consultants may investigate organizational challenges, recommend approaches, implement solutions, and support adoption. The scope of that work varies considerably, and it would be inaccurate to assume that consulting is exclusively advisory or that consultants do not perform production engineering.</p><p>Sales engineers and technical specialists also contribute to requirements discovery, demonstrations, proofs of concept, and technical decision-making. In some organizations, these roles include substantial development responsibilities.</p><p>The Forward Deployed Engineer model draws from several of these disciplines while generally placing greater emphasis on continuity between understanding a customer’s problem and contributing directly to the engineering work required to address it.</p><p>This distinction should not be interpreted as a hierarchy in which one role is inherently more technical or valuable than another. Many organizations already combine these responsibilities under different titles, and the practical differences depend heavily on how teams are structured.</p><p>What makes the forward-deployed model notable is its attempt to reduce the distance between technical decision-making and the environment where the resulting software will be used.</p><p>An engineer may need to move between architectural discussions, implementation work, stakeholder demonstrations, and operational investigation within the same engagement. That breadth creates a different working rhythm from positions focused primarily on one component or stage of the development lifecycle.</p><p>It also requires engineers to communicate effectively across audiences. A technical decision may need to be explained to developers in terms of interfaces, dependencies, and performance, while the same decision must be communicated to organizational leadership in terms of risk, feasibility, cost, and expected outcomes.</p><p>The ability to connect these perspectives is an important part of the role’s practical value.</p><h3>Why the Model Matters in Enterprise and Mission-Oriented Environments</h3><p>Enterprise technology environments introduce constraints that are not always visible during initial demonstrations.</p><p>Organizations may depend on established applications, fragmented information sources, specialized identity systems, and operational processes that have developed over many years. Introducing AI into these environments requires understanding the dependencies and responsibilities surrounding the systems being modified.</p><p>Mission-oriented organizations can introduce additional considerations associated with operational objectives, authorization boundaries, information handling, continuity requirements, and infrastructure restrictions.</p><p>These requirements differ significantly between organizations and operational environments, and no single engineering approach applies uniformly across all of them. Nevertheless, they illustrate why technical proximity to the operating context can be valuable.</p><p>An AI-enabled application that performs well in a controlled demonstration may require substantial adaptation before it can interact with an organization’s actual systems and information sources. Certain integrations may be unavailable, deployment options may be restricted, and operational expectations may require capabilities beyond those necessary to validate an initial concept.</p><p>A forward-deployed engineer can contribute by identifying these constraints early and incorporating them into the design process.</p><p>For example, consider a fictional organization evaluating an AI-powered knowledge assistant to improve access to internal procedures. An initial technical assessment might concentrate on retrieval accuracy and the quality of generated responses. A broader engineering investigation would also examine source authority, user-specific permissions, information freshness, deployment restrictions, and the processes required to maintain the application after delivery.</p><p>These considerations can materially influence whether the proposed architecture is appropriate.</p><p>The value of the FDE model in such environments is not simply that engineers are available to develop software more quickly. It is that engineering decisions can be informed by a closer understanding of the organizational requirements and operational constraints that determine whether the solution will remain useful.</p><p>This also requires recognizing when AI is not the most appropriate answer. Improving an existing integration, restructuring a workflow, or establishing better information management practices may sometimes address the underlying problem more effectively than introducing an additional AI capability.</p><p>Effective forward-deployed engineering should allow those conclusions to emerge through technical investigation rather than treating adoption of a particular technology as the predetermined outcome.</p><h3>The Relationship Between Field Engineering and Product Development</h3><p>An important but sometimes overlooked aspect of forward-deployed engineering is its potential contribution to the broader technology organization.</p><p>Engineering teams developing reusable products must make decisions about which capabilities should be standardized, which integrations deserve continued investment, and which limitations affect a broad set of customers.</p><p>Customer-facing engineers frequently encounter these questions through direct implementation work.</p><p>A limitation that appears isolated during one engagement may reveal a recurring product issue. A custom integration developed to address a specific requirement may suggest an opportunity for a reusable connector, architectural pattern, or improvement to the underlying platform.</p><p>This creates a feedback relationship between engineers working directly with operational problems and the teams responsible for evolving the technology.</p><p>The relationship is particularly important in AI because development platforms, model capabilities, and implementation patterns continue to change rapidly. Technical assumptions that were reasonable during an earlier engagement may become less relevant as new capabilities become available, while recurring deployment challenges can help identify where broader platform improvements would provide meaningful value.</p><p>However, this model also introduces a potential tension between customer-specific development and long-term product maintainability.</p><p>An organization may need a specialized capability that provides immediate value but has limited relevance elsewhere. Developing that capability can be appropriate, although treating every customer requirement as a reason to modify the core platform would make the product increasingly difficult to maintain.</p><p>Forward-deployed teams therefore need judgment about which solutions should remain specific to an engagement and which insights deserve to be generalized.</p><p>Reusable technical patterns, clear documentation, and structured feedback can help preserve the value of field experience without requiring every implementation to become a permanent exception.</p><p>When this relationship works effectively, forward-deployed engineering contributes not only to individual customer outcomes but also to the ongoing improvement of the technologies used to deliver them.</p><h3>The Challenges of a Role That Spans Multiple Disciplines</h3><p>The breadth of forward-deployed engineering can also make the role difficult to manage.</p><p>Engineers working directly with stakeholders may encounter changing priorities, ambiguous requirements, implementation challenges, and pressure to demonstrate value within limited timeframes. The work can require frequent transitions between strategic discussions and detailed technical activities, often within the same engagement.</p><p>This creates a need for clear expectations about ownership and delivery responsibilities.</p><p>A role that spans discovery, architecture, implementation, and stakeholder engagement can become ineffective when every responsibility is treated as equally urgent or when success is measured primarily through the number of demonstrations completed.</p><p>There is also a risk that customer-specific development becomes difficult to transfer or maintain. Solutions created through rapid iteration may depend heavily on the engineer who understands the original decisions, particularly when documentation, testing, and operational handover receive insufficient attention.</p><p>These risks are not exclusive to forward-deployed engineering, but the pace and breadth of the role can make them more visible.</p><p>A sustainable model should establish which activities the FDE owns, how work is coordinated with product and delivery teams, and what evidence is required before a solution can be considered ready for its intended environment.</p><p>It should also recognize that technical expertise alone is insufficient. Strong communication, sound prioritization, adaptability, and the ability to operate under incomplete information are essential when engineering decisions depend on both technology and organizational context.</p><p>The most effective practitioners are not necessarily those who can implement the largest number of features in the shortest time. They are engineers capable of recognizing which problems deserve attention, identifying the constraints that matter, and selecting approaches that produce dependable outcomes without unnecessary complexity.</p><h3>Where Forward-Deployed Engineering Goes Next</h3><p>The growing capabilities of AI-assisted development tools are likely to influence how forward-deployed engineers spend their time.</p><p>As repetitive coding tasks become easier to automate, engineers may be able to explore alternatives, build prototypes, and investigate unfamiliar systems more quickly. AI agents may also assist with repository analysis, integration development, test generation, documentation, and other activities that traditionally require considerable manual effort.</p><p>These improvements could reduce the time required for certain implementation tasks, but they do not automatically simplify the decisions surrounding them.</p><p>Understanding whether an organization should automate a process, which information can be trusted, how authorization should be enforced, and what constitutes an acceptable operational outcome will continue to require deliberate technical and organizational judgment.</p><p>The forward-deployed model is well positioned to engage with these questions because its responsibilities already extend beyond code generation.</p><p>At the same time, there is no guarantee that the role will develop into one standardized profession. Technology providers, AI development organizations, consulting firms, and enterprise engineering teams may continue to define forward-deployed responsibilities differently according to their operating models and delivery approaches.</p><p>Some may emphasize production ownership and embedded software development. Others may concentrate on technical discovery, architecture, iterative validation, or multidisciplinary delivery models supported by AI development tools.</p><p>That variation does not necessarily undermine the relevance of the role. It reflects the different ways organizations are attempting to address the gap between technological capability and practical adoption.</p><p>What matters is whether the operating model gives engineers the context, authority, technical resources, and organizational support required to make meaningful progress on the problems they are assigned.</p><h3>Engineering Closer to the Problem</h3><p>Forward-deployed engineering is gaining attention at a time when powerful AI capabilities are becoming increasingly accessible, but successfully incorporating them into established organizations remains a substantial engineering responsibility.</p><p>The role builds on a long history of customer-facing technical work while placing renewed emphasis on combining hands-on engineering, architectural judgment, and direct engagement with operational requirements.</p><p>Its value is not defined by proximity to a customer alone, nor by the range of technologies an engineer can use. It depends on the ability to translate an initially expressed need into a technically appropriate solution, evaluate that solution against realistic constraints, and help establish whether the resulting capability produces meaningful value.</p><p>As organizations continue adopting AI, these responsibilities are likely to remain important even as the tools used to perform them evolve. More capable models may accelerate implementation, but they do not independently resolve questions about requirements, system ownership, integration, security, or operational readiness.</p><p>The rise of the AI Forward Deployed Engineer reflects a broader recognition that engineering outcomes depend on more than the sophistication of the technology being introduced. They depend on how effectively that technology is understood, adapted, and integrated into the environments where it is expected to operate.</p><p>Forward-deployed engineering provides one approach to closing that distance, bringing technical execution closer to the realities of the problems software is intended to solve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d1dae8f7616a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why AI Can Sound Certain and Still Be Wrong]]></title>
            <link>https://medium.com/@bryan.pesquera/why-ai-can-sound-certain-and-still-be-wrong-84c4debba7af?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/84c4debba7af</guid>
            <category><![CDATA[large-language-models]]></category>
            <category><![CDATA[generative-ai]]></category>
            <category><![CDATA[ai-hallucination]]></category>
            <category><![CDATA[machine-learning]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Wed, 04 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-04T15:11:01.625Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9Icr5yHO49J_LwRbrGo56w.png" /><figcaption>AI-generated responses can appear coherent and authoritative even when their underlying claims are inaccurate or unsupported.</figcaption></figure><p>Ask a modern AI system a technical question, and it may respond with a detailed explanation, precise terminology, and a seemingly logical sequence of conclusions. The response can resemble something written by a knowledgeable professional, complete with examples, supporting arguments, and occasionally even citations.</p><p>Yet the explanation may be partially or entirely incorrect.</p><p>This behavior is often described as <em>AI hallucination</em>, but the term alone does little to explain why it occurs. The underlying issue is more fundamental: large language models are capable of producing linguistically convincing responses without independently establishing whether the information they generate is factually correct.</p><p>Understanding this distinction requires examining how language models represent information, generate responses, and handle uncertainty.</p><h3>How Language Models Generate Responses</h3><p>Large language models operate by estimating probability distributions over sequences of tokens. Tokens are units of text that may represent words, portions of words, punctuation, or other elements.</p><p>During generation, the model processes the preceding context and produces a probability distribution over possible next tokens. A decoding strategy then selects a token, which becomes part of the context for subsequent predictions.</p><p>The process repeats until the response is complete.</p><p>However, describing this mechanism as simply predicting the next word can be misleading. Modern transformer-based models learn complex representations of language, relationships, concepts, and patterns through training. These representations allow models to perform tasks involving translation, programming, mathematical reasoning, and structured problem-solving.</p><p>Nevertheless, the immediate generation objective is not equivalent to independently verifying the factual accuracy of every statement.</p><p>A model can generate a response that is statistically consistent with patterns learned during training while still producing an incorrect conclusion.</p><h3>Why Fluency Is Not Evidence of Accuracy</h3><p>Language models are trained on large collections of text containing explanations, arguments, documentation, conversations, and other forms of written communication.</p><p>Through this process, they learn not only information but also the linguistic structures associated with expertise.</p><p>A model may learn how technical explanations are typically organized, which terminology appears in a particular domain, and how authoritative statements are commonly expressed.</p><p>This creates an important distinction between <em>linguistic fluency</em> and <em>epistemic reliability</em>.</p><p>Linguistic fluency describes the ability to produce coherent, contextually appropriate language. Epistemic reliability concerns whether a system’s claims are supported by accurate information and valid reasoning.</p><p>The two properties can overlap, but one does not guarantee the other.</p><p>For example, a model might provide a plausible explanation of a software vulnerability while incorrectly identifying the affected library version. The surrounding technical discussion may be accurate, making the incorrect detail more difficult to recognize.</p><p>The model’s ability to express the claim convincingly does not establish that the claim is true.</p><h3>Where Hallucinations Come From</h3><p>Hallucinations do not arise from a single mechanism. They can result from several interacting limitations in training, inference, and information availability.</p><p>Training data may contain inaccuracies, contradictions, outdated information, or incomplete explanations. A model may also generalize incorrectly from patterns it has learned, combining individually plausible details into a statement that is unsupported.</p><p>Another source of error is the absence of relevant information.</p><p>When asked about a document, event, or technical specification that is not available in its current context, a model may still produce a response based on related patterns rather than explicitly identifying the information gap.</p><p>This can result in fabricated references, nonexistent software features, incorrect quotations, or invented historical details.</p><p>Importantly, these errors are not necessarily random. They can be structurally consistent with the subject matter, which makes them particularly convincing.</p><p>A fabricated academic citation, for instance, may follow the correct formatting conventions and reference a plausible research topic while pointing to a publication that does not exist.</p><h3>Does the Model Know When It Is Wrong?</h3><p>Language models can express uncertainty, estimate confidence, and sometimes identify mistakes in their own responses. However, these capabilities should not be confused with a reliable internal mechanism for determining truth.</p><p>The probability assigned to a generated token is not the probability that the corresponding factual claim is correct.</p><p>A model may assign relatively high probability to a sequence of tokens because that sequence is linguistically or contextually likely, even when the resulting statement is false.</p><p>Likewise, phrases such as “I’m certain” or “there is no doubt” are generated language, not direct measurements of factual certainty.</p><p>Researchers study <em>calibration</em>, which concerns how well a system’s expressed confidence corresponds to its actual accuracy. Although calibration techniques can improve uncertainty estimates, reliably measuring confidence across diverse tasks remains difficult.</p><p>Additional reasoning steps can help models solve certain problems and identify inconsistencies, but they do not guarantee correctness. A model can construct a coherent sequence of reasoning around an incorrect assumption and arrive at a conclusion that appears justified.</p><p>The existence of an explanation is not proof that the explanation is valid.</p><h3>Can Hallucinations Be Prevented?</h3><p>Several engineering approaches can reduce hallucinations by providing models with more reliable information or introducing mechanisms for checking their outputs.</p><p>One common technique is <em>retrieval-augmented generation</em>, or RAG. Instead of relying exclusively on information represented in model parameters, a RAG system retrieves relevant documents and supplies them as context for generating a response.</p><p>This can improve factual accuracy, particularly when answering questions about proprietary, specialized, or frequently changing information.</p><p>However, retrieval does not guarantee correctness. The retrieved material may be irrelevant, incomplete, outdated, or misinterpreted by the model.</p><p>Other approaches involve connecting models to external tools, executing code to validate calculations, checking generated claims against authoritative sources, and using structured evaluation systems.</p><p>These techniques shift part of the reliability problem away from language generation and toward evidence collection and verification.</p><p>Even then, system reliability depends on the quality of the available evidence and the effectiveness of the validation process.</p><h3>The Difference Between Generating an Answer and Establishing Truth</h3><p>The central limitation is not that language models are incapable of producing accurate information. Modern models can perform remarkably well across many technical and analytical tasks.</p><p>The limitation is that producing a coherent response and establishing the truth of that response are fundamentally different operations.</p><p>Language models generate outputs using learned representations and the information available in their context. They do not inherently perform an independent factual verification process for every claim they produce.</p><p>This is why a response can be detailed, internally consistent, and expressed with apparent certainty while containing significant errors.</p><p>For users, the practical implication is straightforward: confidence in an AI-generated explanation should come from the quality of its supporting evidence and the reliability of its verification process, not from how convincingly the explanation is written.</p><p>For engineers building AI systems, the distinction is even more important. Reliable applications require mechanisms for grounding responses, detecting uncertainty, validating outputs, and handling situations where sufficient information is unavailable.</p><p><strong>The ability to generate a plausible answer is not the same as the ability to demonstrate that the answer is correct.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84c4debba7af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Case for Small, Purpose-Built Software in an Increasingly Complex World]]></title>
            <link>https://medium.com/@bryan.pesquera/the-case-for-small-purpose-built-software-in-an-increasingly-complex-world-fe3715dac77d?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/fe3715dac77d</guid>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Mon, 02 Nov 2026 15:11:01 GMT</pubDate>
            <atom:updated>2026-11-02T15:11:01.707Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Why focused applications can offer a better fit for specific problems, and how to recognize when the complexity of a larger platform is justified.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pTKogJp7YdDXO77JTZzwyg.png" /><figcaption>Purpose-built software can complement larger platforms by solving well-defined problems through focused functionality and clear integration boundaries, keeping complexity proportionate to the task.</figcaption></figure><p>Modern software platforms bring an extensive range of capabilities into a single environment. Communication, analytics, automation, data management, and artificial intelligence can coexist within systems designed to support entire organizations. This breadth can be valuable, particularly when it allows teams to consolidate information, standardize processes, and avoid maintaining disconnected applications. For organizations with complex operational requirements, a comprehensive platform may provide essential infrastructure rather than unnecessary overhead.</p><p>However, the relationship between functionality and usefulness is not always straightforward. A platform may be capable of supporting a particular task while requiring users to navigate configuration options, administrative processes, and interfaces that extend well beyond what the task actually demands. The additional capabilities may serve other parts of the organization, but they still influence the experience of the team trying to solve a relatively narrow problem. What looks like a convenient consolidation from one perspective can feel like an elaborate dependency from another.</p><p>This is where purpose-built software deserves consideration. A focused application can address a specific requirement without attempting to become the environment in which every related activity takes place. Its value does not come from being small for its own sake, but from establishing a close relationship between the problem, the functionality required to solve it, and the responsibilities involved in keeping the solution useful. The engineering question is not whether smaller software is inherently better, but whether a narrower solution can meet the need without introducing costs that outweigh its advantages.</p><h3>A Clear Problem Creates a Useful Architectural Boundary</h3><p>Software projects often begin with a recognizable problem and gradually expand into something less clearly defined. A team needs to track recurring activities, so an application is built to create tasks and record their status. Reporting is added, followed by notifications, configurable workflows, external integrations, and additional administrative functions. Each request may have a reasonable justification, but the cumulative result can be a system whose responsibilities are much broader than its original purpose.</p><p>Expansion is not necessarily a sign of poor design. Software should evolve when users need capabilities that genuinely improve their work, and an application that remains permanently constrained by its first implementation may become an obstacle. The difficulty arises when new functionality is accepted without reconsidering what the application is becoming. Features that appear inexpensive in isolation can create dependencies and expectations that change the cost of maintaining the entire system.</p><p>A clearly defined problem provides a practical basis for evaluating those decisions. Consider a developer tool intended to identify potentially sensitive information in source code. Its essential responsibilities might include examining supported files, identifying patterns associated with credentials, and presenting findings for review. User accounts, centralized reporting, remote storage, and organizational dashboards could become useful under different requirements, but they are not automatically necessary to deliver the original capability.</p><p>This distinction helps separate a product’s present responsibilities from its possible future directions. Rather than building an extensive foundation for every capability the tool might eventually support, an engineer can design around the work it needs to perform now while preserving reasonable options for change. That does not mean ignoring future requirements or avoiding useful abstractions. It means asking whether an architectural decision addresses an actual constraint or merely anticipates a scenario that may never become relevant.</p><p>The same principle applies when choosing existing software. A small team that needs to record a few operational statuses should evaluate whether a broader platform makes that work easier, not simply whether it can be configured to perform it. If the organization already uses the platform, extending it may be the simplest and most responsible approach. If adopting it would introduce substantial administration and training for a narrow requirement, a focused application may deserve closer consideration.</p><h3>Features Create Responsibilities Beyond the Release</h3><p>The initial implementation of a feature is only part of its cost. Once users depend on it, the feature needs to remain understandable, compatible with the surrounding system, and reliable under conditions that were not necessarily present during development. It also creates expectations about documentation, support, security, and future behavior. A capability that took little time to build can still become a lasting operational responsibility.</p><p>This is one reason purpose-built software can be attractive to small teams and independent developers. Keeping an application focused may reduce the number of dependencies, deployment components, configuration options, and user-facing behaviors that need attention. A local processing tool, for example, may avoid operating a remote service or maintaining a centralized database. Those architectural choices do not eliminate maintenance, but they can remove entire categories of work that would otherwise require ongoing ownership.</p><p>The advantage should not be overstated, however. A local application still needs appropriate handling of sensitive information, dependency updates, compatibility testing, and a reliable distribution process. A small internal service may still require authentication, monitoring, backups, and incident response. Reducing the size of a system does not remove responsibilities that follow from the sensitivity of its data or the consequences of its actions.</p><p>There are also circumstances in which a larger platform reduces the total burden of ownership. A mature service may already provide identity integration, recovery mechanisms, administrative controls, and support arrangements that a custom application would need to establish independently. Building a smaller interface does not necessarily create a smaller operational commitment if the team must recreate those capabilities behind it. The useful comparison is therefore between the complete responsibilities of each option, rather than between their feature counts or the apparent simplicity of their interfaces.</p><h3>Focused Software Should Still Fit Into a Larger System</h3><p>A purpose-built application does not need to operate in isolation. It can perform a narrow responsibility while relying on established systems for identity, storage, communication, or workflow management. This allows a team to introduce a specialized capability without duplicating every service the organization already uses. In many cases, the strongest argument for a small application is not that it replaces a platform, but that it fills a specific gap within the existing environment.</p><p>Consider a service that extracts structured information from a particular category of documents. It may need to accept supported files, validate their contents, perform processing, and return results in a predictable format. The surrounding application can remain responsible for user access, document ownership, approvals, and the business process in which those results are used. Keeping those responsibilities separate can make the processing component easier to understand and reuse without requiring it to become a complete document management system.</p><p>That separation only remains useful when the interfaces are well designed. The systems involved need a consistent understanding of accepted inputs, expected outputs, errors, and ownership of intermediate state. Authentication, versioning, and failure handling become part of the integration rather than optional refinements. A narrowly scoped component can still create significant complexity when its callers cannot determine whether an operation completed or what they should do when it fails.</p><p>It is also important not to confuse a focused responsibility with a requirement for a separately deployed service. The appropriate implementation might be a module inside an existing application, an editor extension, a command-line utility, or a small library. Splitting every responsibility into its own networked service can create more operational work than the separation is worth. The architectural objective is a clear boundary, not the largest possible collection of independently deployed components.</p><h3>Simplicity Is Not the Absence of Engineering</h3><p>A simple application can require substantial engineering effort because much of the work involves deciding what users should not have to manage. Predictable behavior, appropriate defaults, clear error messages, and straightforward recovery often depend on careful choices beneath the interface. Removing visible options without addressing the underlying problem may produce a cleaner screen while leaving users with more manual work. Useful simplicity reduces the effort required to complete a task rather than merely reducing what the application displays.</p><p>This requires distinguishing between complexity inherent to the problem and complexity introduced by the implementation. A system that changes financial records may need strong validation, auditability, and recovery controls even when its interface contains only a few fields. A tool that modifies access permissions must respect authorization boundaries regardless of how narrowly its purpose is defined. These responsibilities cannot be removed simply because the application is intended to remain lightweight.</p><p>Other forms of complexity are more discretionary. A small application used by a single team may not benefit from an architecture designed around numerous independently deployed services, elaborate routing layers, and infrastructure intended for substantially different operating conditions. Those choices may become appropriate as requirements change, but they need a present justification. Adopting them in advance can force a team to support architectural machinery that contributes little to the actual user experience.</p><p>The same judgment applies to functionality. A focused application should not omit necessary capabilities merely to preserve an appearance of minimalism. If users routinely need to export information, correct mistakes, or recover previous work, those requirements belong in the design. Scope discipline is about resisting unnecessary expansion while taking the intended workflow seriously, including the less visible work of handling exceptions and mistakes.</p><h3>Faster Development Makes Scope Discipline More Important</h3><p>Development frameworks, managed services, and AI-assisted programming can reduce the effort involved in producing an initial implementation. They can help developers assemble interfaces, work through integration code, and explore alternative approaches without building every component from the beginning. For a narrowly defined problem, that can make experimentation more practical. It can also make it easier to confuse the ability to generate functionality with a reason to include it.</p><p>When another feature appears inexpensive to create, its longer-term consequences can receive less attention. A generated administrative page still needs appropriate permissions, an additional integration still depends on another system, and a new configuration option still needs to behave consistently with the rest of the application. The source of the implementation does not change the responsibility to understand, test, and maintain it. Producing code quickly is useful, but it does not resolve questions about whether the code belongs in the product.</p><p>For purpose-built software, the most valuable use of faster development may be to improve the essential experience rather than broaden the scope. Time saved on repetitive implementation work can be directed toward validation, accessibility, documentation, error handling, and testing realistic usage conditions. A tool that performs a modest task predictably can be more useful than one with a larger feature set whose behavior becomes uncertain outside the expected path. The opportunity is to deliver a more dependable solution, not simply a more extensive one.</p><h3>When a Larger Platform Is the Better Decision</h3><p>There are clear limits to the argument for specialized applications. Organizations need to consider the cumulative effect of allowing teams to introduce independent tools, even when each tool appears reasonable on its own. Separate databases, permission models, deployment processes, and support arrangements can create fragmentation that is difficult to manage. What saves time for one team may create additional work for the people responsible for security, operations, and organizational continuity.</p><p>A comprehensive platform can be especially valuable when the important requirements are shared across many workflows. Identity integration, centralized policies, reporting, availability, and recovery may be difficult to provide consistently through a collection of independent applications. An existing platform may also offer a familiar operating model for administrators and users. These advantages can outweigh the inconvenience of configuration or the presence of features that a particular team does not need.</p><p>Long-term ownership is another important consideration. A small custom application can become operationally significant even when it began as a convenience. If its original developer changes roles or becomes unavailable, someone still needs to understand its dependencies, resolve problems, and make necessary changes. A solution that is easy for its creator to maintain is not automatically easy for an organization to own, particularly when documentation and support arrangements have not developed alongside its use.</p><p>For these reasons, the choice does not have to be between replacing a platform and accepting every limitation of that platform. A focused extension may provide the missing interface or processing capability while continuing to use established services for the responsibilities they already handle well. This can preserve organizational consistency without forcing every specialized requirement into a general-purpose configuration model. The most appropriate architecture may be a combination of shared infrastructure and carefully bounded custom software.</p><h3>Choosing a Proportionate Solution</h3><p>Before building a purpose-built application, it is worth examining whether the requirement is genuinely distinct. A problem that appears to justify custom development may already be addressed through a straightforward feature or configuration change in an existing system. That possibility should be evaluated against the actual workflow rather than dismissed because a new application would be more interesting to build. Custom software is most defensible when it provides a meaningful improvement that existing options do not offer at a reasonable cost.</p><p>The proposed scope should also be tested against the surrounding process. A tool may seem narrow until it needs to manage exceptions, coordinate with other teams, preserve records, and support administrative review. Understanding those requirements early helps reveal whether the application can remain focused or whether the apparent simplicity depends on leaving essential work outside the design. A small solution should reduce the overall burden of the process, not transfer it to spreadsheets, email exchanges, or undocumented manual steps.</p><p>Ownership and evaluation belong in the same decision. The team should understand who will maintain the application, how changes will be tested, and what happens when a dependency or integration stops working. It should also have a reasonable basis for judging whether the tool improves the task it was built to support. Better usability, fewer manual steps, reduced processing time, or a smaller infrastructure footprint may justify the investment, but those benefits should be assessed alongside the continuing cost of support.</p><p>The decision can be revisited as the application evolves. A tool that begins with one well-defined responsibility may eventually need a broader architecture, or it may become more sensible to move its functionality into an established platform. Neither outcome means the original approach was necessarily wrong. Good scope discipline includes recognizing when the conditions that supported a small solution have changed, rather than protecting the initial design indefinitely.</p><h3>Building What the Problem Requires</h3><p>Purpose-built software remains valuable because many useful problems do not require a comprehensive new platform. A focused application can improve a specific workflow, provide a missing capability, or make an existing system easier to use without assuming responsibility for everything around it. When its boundaries are clear and its maintenance needs are understood, that focus can benefit both the people using the software and the people supporting it. Its strength comes from an appropriate scope, not from a rejection of architectural sophistication.</p><p>Larger platforms remain equally valid when shared controls, organizational scale, and long-term operational requirements justify their breadth. Their complexity may represent capabilities that a smaller application would otherwise need to recreate or responsibilities that its users cannot afford to leave unresolved. The engineering task is to distinguish that necessary complexity from additions that contribute little to the problem at hand. That distinction requires understanding the workflow, the surrounding environment, and the full cost of ownership.</p><p>As building software becomes more accessible, choosing what to build remains a consequential part of the work. Engineers still need to decide which responsibilities belong together, which should rely on existing services, and which features justify the obligations they create. Sometimes the right result is a broad platform that supports many interconnected activities; sometimes it is a focused tool that performs one task reliably. Good architecture is defined less by how much a system can do than by how appropriately its design serves the problem it was created to solve.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe3715dac77d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Build Your First VS Code Extension: From Idea to Marketplace]]></title>
            <link>https://medium.com/@bryan.pesquera/build-your-first-vs-code-extension-from-idea-to-marketplace-986f0bc5614f?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/986f0bc5614f</guid>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[visual-studio-code]]></category>
            <category><![CDATA[programming]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Fri, 30 Oct 2026 14:11:01 GMT</pubDate>
            <atom:updated>2026-10-30T14:11:01.673Z</atom:updated>
            <content:encoded><![CDATA[<p><em>An end-to-end guide to developing, testing, and publishing a Visual Studio Code extension on Windows, macOS, or Linux.</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*F59aSOQb9rRpA8BW-2z78g.png" /></figure><p>Developers frequently encounter small inconveniences that are not significant enough to justify adopting another application but occur often enough to make everyday work less efficient. These might involve repetitive file operations, navigating project resources, formatting information, or accessing utilities that would be more convenient directly within the editor. While some problems require substantial software, others can be addressed through narrowly focused tools that integrate into an existing development workflow.</p><p>Visual Studio Code provides an extension platform that makes this kind of development accessible. Extensions can contribute commands, interact with workspace files, introduce custom views, support programming languages, and expand the editor in numerous other ways. For developers already familiar with JavaScript or TypeScript, building an extension provides an opportunity to create useful software without developing an entire standalone application.</p><p>Publishing an extension also introduces responsibilities beyond implementation. Developers must consider how users discover its functionality, how it behaves under unexpected conditions, which resources it requires, and how updates will be distributed after release. Understanding this process can be valuable even for developers who have no immediate plans to distribute their work publicly.</p><p>In this tutorial, we will build a small utility called <strong>Workspace Notes</strong>. The extension will allow developers to create or open a project-specific Markdown file directly from the VS Code Command Palette. It will support multiple workspace folders, preserve existing notes, and provide feedback when an operation cannot be completed.</p><p>The implementation uses TypeScript and Visual Studio Code’s official extension APIs, allowing the same code to run across Windows, macOS, and Linux. Although some development environment details differ between operating systems, the actual extension does not require separate implementations.</p><p>By the end, we will have a functioning extension that can be tested locally, packaged into a VSIX file, and prepared for publication on the Visual Studio Marketplace.</p><h3>Choosing a Small Problem Worth Solving</h3><p>A first extension benefits from having a clearly defined responsibility. Introducing elaborate interfaces, background services, external APIs, or persistent configuration before understanding the extension lifecycle can make it unnecessarily difficult to distinguish problems in the application from problems in the VS Code integration.</p><p>Workspace Notes addresses a simple need: keeping development notes alongside the project to which they relate.</p><p>A developer might want to record implementation decisions, outstanding tasks, debugging observations, or references without opening a separate note-taking application. Although VS Code already supports creating Markdown files manually, a dedicated command can standardize where the file is created and remove a few repetitive steps.</p><p>The intended behavior is straightforward. When a user invokes the command, the extension identifies the relevant workspace folder and checks for a file named WORKSPACE_NOTES.md. If the file exists, it opens it. Otherwise, the extension creates it with a basic structure and opens the newly created document.</p><p>There are a few conditions worth considering before implementation. VS Code can operate without an open workspace, users can open multiple folders simultaneously, and filesystem operations can fail because of permissions or unavailable resources. We will account for these situations without introducing an elaborate architecture.</p><p>This is a useful scope for a first extension because it introduces several capabilities of the VS Code API while keeping the core behavior small enough to understand completely.</p><h3>Preparing the Development Environment</h3><p>Building a Visual Studio Code extension requires a relatively straightforward development environment. The process is supported on Windows, macOS, and Linux, and the implementation we will create does not depend on a particular operating system.</p><p>Before beginning, install <a href="https://code.visualstudio.com/">Visual Studio Code</a>, <a href="https://nodejs.org/">Node.js</a>, and <a href="https://git-scm.com/">Git</a>. Node.js includes npm, which we will use to install development dependencies and run the tools required to generate, compile, and package the extension. Git is useful for tracking changes throughout development and maintaining the project if it is eventually published to a public repository.</p><p>Installation procedures differ slightly between operating systems. Windows developers can install Node.js through its official installer and run commands using PowerShell or Command Prompt. macOS developers can use the official Node.js installer or a package manager such as Homebrew, while Linux developers can install an appropriate Node.js version through their distribution’s supported installation methods or a Node.js version manager.</p><p>Once the required tools are installed, open a terminal and verify that Node.js and npm are available:</p><pre>node --version<br>npm --version</pre><p>These commands work on all three operating systems. If either command cannot be found, verify the installation and confirm that the executable is available through the terminal’s PATH environment variable.</p><p>Microsoft provides an official Yeoman-based extension generator that creates the initial project structure, including TypeScript configuration, development scripts, and debugging settings. Rather than creating these files manually, we can use the generator to establish a consistent starting point.</p><p>Run the following command in your terminal:</p><pre>npx --package yo --package generator-code -- yo code</pre><p>The command is identical on Windows, macOS, and Linux. It runs the required generator packages through npm without requiring a permanent global installation.</p><p>When prompted, select <strong>New Extension (TypeScript)</strong> and provide the following project information:</p><ul><li><strong>Extension name:</strong> Workspace Notes</li><li><strong>Extension identifier:</strong> workspace-notes</li><li><strong>Description:</strong> Create and open project-specific Markdown notes.</li><li><strong>Bundler:</strong> Unbundled, if the option is presented</li><li><strong>Package manager:</strong> npm</li></ul><p>You can also initialize a Git repository when prompted. Once the generator finishes, open the project in Visual Studio Code.</p><p>The generated project contains several configuration and source files, but two are particularly important for understanding how the extension works. The package.json file serves as the extension manifest, defining its identity, supported editor versions, commands, and other contributions. The src/extension.ts file contains the TypeScript implementation, including the behavior that executes when a user invokes a registered command.</p><p>The generator also creates the configuration required for compiling and debugging the extension. We can retain these defaults for the tutorial, allowing the implementation to remain focused on the VS Code Extension API rather than introducing additional build infrastructure.</p><h3>Platform Compatibility: Windows, macOS, and Linux</h3><p>Workspace Notes is designed for the desktop versions of Visual Studio Code on Windows, macOS, and Linux. Because the extension is implemented in TypeScript and interacts with the editor through its official APIs, the same source code can be used across all three operating systems without maintaining separate implementations.</p><p>The primary differences involve development environment setup, terminal configuration, and keyboard shortcuts. Windows commonly uses PowerShell or Command Prompt, macOS typically uses Terminal with Zsh, and Linux provides a variety of terminal applications and shells. These differences do not affect the npm commands used to generate, compile, or package the extension.</p><p>For debugging, Visual Studio Code provides a consistent Extension Development Host across supported desktop platforms. Developers can generally press F5 to start the extension, although some macOS keyboards may require Fn+F5. The Command Palette can be opened using Ctrl+Shift+P on Windows and Linux or Cmd+Shift+P on macOS.</p><p>Filesystem compatibility is also an important consideration. The implementation uses vscode.Uri.joinPath and vscode.workspace.fs rather than constructing paths using operating-system-specific separators or assuming files always exist on a conventional local disk. This allows VS Code to manage filesystem operations through its supported workspace providers and reduces the need for platform-specific file handling.</p><p>The same design provides a useful foundation for working with remote development environments, including SSH connections, development containers, and Windows Subsystem for Linux. However, remote and virtual workspaces may introduce different filesystem behaviors, permissions, or extension-host configurations, so compatibility with those environments should be verified separately.</p><p>For the extension developed in this tutorial, a single TypeScript implementation and a standard VSIX package are sufficient for the supported desktop operating systems. Separate platform-specific packages are generally necessary only when an extension depends on native modules, operating-system-specific executables, or other platform-dependent components.</p><p>This tutorial does not specifically target browser-based VS Code environments such as vscode.dev. Web extensions operate within a different runtime environment and may require additional configuration, packaging considerations, and compatibility testing.</p><h3>Understanding How VS Code Loads an Extension</h3><p>A VS Code extension interacts with the editor through a defined API. It does not need to modify the editor’s source code or operate as a separate application.</p><p>The extension manifest declares functionality that VS Code can discover, while the extension’s implementation registers the behavior associated with that functionality.</p><p>For Workspace Notes, we need one command. Its identifier will be workspace-notes.openNotes, and its visible title will be <strong>Workspace Notes: Open Notes</strong>.</p><p>Open package.json and locate the contributes property. Configure its commands array as follows:</p><pre>{<br>  &quot;contributes&quot;: {<br>    &quot;commands&quot;: [<br>      {<br>        &quot;command&quot;: &quot;workspace-notes.openNotes&quot;,<br>        &quot;title&quot;: &quot;Workspace Notes: Open Notes&quot;<br>      }<br>    ]<br>  }<br>}</pre><p>This is a manifest fragment, not a replacement for the entire package.json file. The generated project contains additional fields required for the extension to function, including its entry point, compatibility requirements, and development scripts.</p><p>If the generator already created a sample command, replace that command’s declaration rather than adding an unrelated duplicate.</p><p>The command identifier connects the manifest declaration with the implementation we will register in TypeScript. The title determines how the command appears in the Command Palette.</p><p>In VS Code 1.74 and later, commands declared through the extension manifest automatically activate the extension when invoked, so a separate onCommand activation event is not required for this example. Extensions targeting older versions need the corresponding activation event declared explicitly.</p><p>This separation between declarative contributions and executable behavior is a central part of the VS Code extension model. The manifest tells the editor what functionality exists, while the extension code defines what that functionality actually does.</p><h3>Implementing Workspace Notes</h3><p>Open src/extension.ts and replace the generated example implementation with the following code.</p><pre>import * as vscode from &#39;vscode&#39;;<br><br>const COMMAND_ID = &#39;workspace-notes.openNotes&#39;;<br>const NOTES_FILE = &#39;WORKSPACE_NOTES.md&#39;;<br><br>export function activate(context: vscode.ExtensionContext) {<br>  const command = vscode.commands.registerCommand(<br>    COMMAND_ID,<br>    async () =&gt; {<br>      const folders = vscode.workspace.workspaceFolders;<br>      if (!folders || folders.length === 0) {<br>        vscode.window.showWarningMessage(<br>          &#39;Open a workspace folder to use Workspace Notes.&#39;<br>        );<br>        return;<br>      }<br>      let folder: vscode.WorkspaceFolder;<br>      if (folders.length === 1) {<br>        folder = folders[0];<br>      } else {<br>        const selected = await vscode.window.showQuickPick(<br>          folders.map(item =&gt; ({<br>            label: item.name,<br>            description: item.uri.toString(),<br>            folder: item<br>          })),<br>          {<br>            placeHolder: &#39;Select a workspace folder&#39;<br>          }<br>        );<br>        if (!selected) {<br>          return;<br>        }<br>        folder = selected.folder;<br>      }<br>      const notesUri = vscode.Uri.joinPath(<br>        folder.uri,<br>        NOTES_FILE<br>      );<br>      try {<br>        let exists = true;<br>        try {<br>          await vscode.workspace.fs.stat(notesUri);<br>        } catch (error) {<br>          if (<br>            error instanceof vscode.FileSystemError &amp;&amp;<br>            error.code === &#39;FileNotFound&#39;<br>          ) {<br>            exists = false;<br>          } else {<br>            throw error;<br>          }<br>        }<br>        if (!exists) {<br>          const content =<br>            `# ${folder.name} Notes\n\n` +<br>            `## Tasks\n\n- [ ] \n\n` +<br>            `## Decisions\n\n` +<br>            `## References\n`;<br>          await vscode.workspace.fs.writeFile(<br>            notesUri,<br>            new TextEncoder().encode(content)<br>          );<br>        }<br>        const document =<br>          await vscode.workspace.openTextDocument(notesUri);<br>        await vscode.window.showTextDocument(document);<br>      } catch (error) {<br>        const message =<br>          error instanceof Error<br>            ? error.message<br>            : String(error);<br>        vscode.window.showErrorMessage(<br>          `Workspace Notes: ${message}`<br>        );<br>      }<br>    }<br>  );<br>  context.subscriptions.push(command);<br>}<br>export function deactivate() {}</pre><p>Although this implementation is relatively small, it demonstrates several important VS Code APIs and development patterns.</p><p>The activate function is called when the extension is activated. Inside it, we register the command using vscode.commands.registerCommand, providing the same identifier declared in the manifest. The returned registration is added to the extension context&#39;s subscriptions so VS Code can dispose of it appropriately when the extension is deactivated.</p><p>The command begins by examining vscode.workspace.workspaceFolders. If no folder is open, the extension displays a warning rather than attempting to write a file to an undefined location.</p><p>When multiple folders are present, it uses vscode.window.showQuickPick to ask the user which workspace should contain the notes file. This is a small addition, but it prevents the extension from silently choosing an unintended destination.</p><p>The file path is constructed using vscode.Uri.joinPath, and filesystem operations are performed through vscode.workspace.fs. Using these APIs rather than assuming every file is accessible through a conventional local operating-system path helps the extension work more appropriately with supported virtual and remote workspaces.</p><p>Before creating the file, the implementation checks whether the target already exists. Importantly, it only treats a FileNotFound error as evidence that the file should be created. Other filesystem errors are allowed to propagate to the outer error handler, where they can be reported to the user.</p><p>This distinction prevents the extension from interpreting every failure as an absent file.</p><p>If the notes file is missing, the extension creates a basic Markdown structure containing sections for tasks, decisions, and references. If the file already exists, its contents are preserved and it is simply opened in the editor.</p><p>There is one implementation detail worth recognizing. The existence check and file creation are separate filesystem operations, so another process could theoretically create the file between those steps. More advanced implementations should account for concurrent modifications and avoid unintended overwrites. For a first extension operating through an interactive command, the example demonstrates the basic behavior without introducing additional coordination mechanisms.</p><p>The implementation is intentionally lightweight. It does not introduce dependencies beyond those required by the generated extension project, store user information remotely, or establish background processing.</p><p>For a production extension, additional testing would be appropriate, particularly around unusual workspace providers and simultaneous file operations. For a first development exercise, the implementation provides a practical starting point with behavior that is easy to inspect and extend.</p><h3>Running and Testing the Extension</h3><p>Before preparing the extension for distribution, we should verify that it behaves correctly within Visual Studio Code. The development and debugging process is nearly identical on Windows, macOS, and Linux because the editor provides a dedicated environment for loading extensions that are still under development.</p><p>From the project’s root directory, open a terminal and run:</p><pre>npm run compile</pre><p>This command compiles the TypeScript implementation into JavaScript using the build configuration created by the extension generator. The compiled output is what Visual Studio Code executes when the extension is activated.</p><p>If compilation completes successfully, press <strong>F5</strong> or select <strong>Run → Start Debugging</strong> from the VS Code menu. On macOS, some keyboards may require Fn+F5, depending on how the function keys are configured.</p><p>Visual Studio Code will open a second window called the <em>Extension Development Host</em>. This environment loads the extension from the development project without requiring a normal Marketplace installation.</p><p>Open a project folder inside the Extension Development Host and access the Command Palette using the appropriate shortcut for your operating system:</p><ul><li><strong>Windows:</strong> Ctrl+Shift+P</li><li><strong>macOS:</strong> Cmd+Shift+P</li><li><strong>Linux:</strong> Ctrl+Shift+P</li></ul><p>Search for <strong>Workspace Notes: Open Notes</strong> and execute the command.</p><p>The extension should create a file named WORKSPACE_NOTES.md in the selected workspace folder and open it in the editor. The document should contain the initial Markdown structure defined in the implementation, including sections for tasks, decisions, and references.</p><p>To verify that existing information is preserved, modify the notes file, save it, and execute the command again. The extension should reopen the existing document without replacing its contents with the original template. This behavior is particularly important because a utility intended to manage notes should not silently overwrite user-created information.</p><p>The extension should also be tested under less typical conditions. Running the command without an open workspace should display a warning rather than attempt to create a file. Opening a multi-root workspace should present a folder selection dialog, allowing the user to choose the intended destination. Canceling that dialog should terminate the operation without creating or modifying anything.</p><p>Additional testing can include attempting to create the notes file in a read-only location or using a workspace where the expected file cannot be accessed. In these cases, the extension should report the error rather than terminate unexpectedly.</p><p>Because the implementation uses VS Code’s filesystem abstraction, these operations follow the same application logic across Windows, macOS, and Linux. Nevertheless, testing on each target operating system remains useful before public distribution, since filesystem permissions, path behavior, and environmental configurations can differ.</p><p>The VS Code debugger can also be used to set breakpoints inside src/extension.ts, inspect variables, and observe how the command executes. This becomes increasingly useful as additional functionality is introduced and the extension begins interacting with more of the editor&#39;s APIs.</p><p>Once the extension behaves as expected in the development environment, the next step is to package it and verify that the distributed version works independently of the source project.</p><h3>Preparing the Extension for Distribution</h3><p>A working extension is not necessarily ready for public distribution. Before publishing, it needs a recognizable identity, appropriate documentation, and an installable package.</p><p>The extension manifest should contain a clear display name, description, version, category, and compatibility requirement. The project generator creates most of these fields, but they should be reviewed before release.</p><p>For Workspace Notes, the core metadata would look something like this:</p><pre>{<br>  &quot;name&quot;: &quot;workspace-notes&quot;,<br>  &quot;displayName&quot;: &quot;Workspace Notes&quot;,<br>  &quot;description&quot;: &quot;Create and open project-specific Markdown notes.&quot;,<br>  &quot;version&quot;: &quot;0.0.1&quot;,<br>  &quot;categories&quot;: [<br>    &quot;Other&quot;<br>  ]<br>}</pre><p>These values should be merged into the existing manifest while preserving the generated engines, main, scripts, dependencies, and command contributions. The extension must also include the identifier of a registered Marketplace publisher before publication.</p><p>Choose a name that accurately describes the extension, and confirm that it does not conflict with an existing Marketplace identifier. The display name should remain clear enough that someone unfamiliar with the project can understand its general purpose.</p><p>The README deserves particular attention because it becomes part of the extension’s public Marketplace listing.</p><p>At a minimum, it should explain what the extension does, how users invoke its command, which files it creates, and what limitations are currently known.</p><p>For Workspace Notes, a concise README could include the following:</p><pre># Workspace Notes<br>A lightweight Visual Studio Code extension for<br>creating and opening project-specific Markdown notes.<br>## Features<br>- Create a notes file in the active workspace<br>- Open existing notes without overwriting them<br>- Support multi-root workspaces<br>- Keep notes alongside project files<br>## Usage<br>1. Open a folder in VS Code.<br>2. Open the Command Palette.<br>3. Run &quot;Workspace Notes: Open Notes&quot;.<br>4. Edit the generated WORKSPACE_NOTES.md file.<br>## Notes<br>The extension operates on workspace files using<br>the VS Code filesystem API.</pre><p>A small extension does not need extensive marketing language, but its documentation should accurately describe what a user can expect.</p><p>I would also include a changelog and an appropriate license if the project is intended for public distribution. A repository URL, screenshots, and a support or issue-reporting location can make the listing more useful, particularly when users encounter problems or want to understand how the project is maintained.</p><p>An icon is optional, but it can help the extension remain recognizable in the Marketplace. VS Code’s publishing documentation supports PNG icons of at least 128 by 128 pixels and applies restrictions to SVG imagery included in published packages.</p><p>Any screenshots or external images referenced from the README should use accessible HTTPS URLs.</p><h3>Packaging the Extension as a VSIX</h3><p>The Visual Studio Code extension ecosystem uses the VSIX format for packaging and distribution.</p><p>Microsoft provides the @vscode/vsce command-line tool for creating VSIX packages and publishing extensions to the Marketplace.</p><p>Install it using npm:</p><pre>npm install --global @vscode/vsce</pre><p>This command can be used on Windows, macOS, and Linux. Depending on how Node.js was installed, some environments may require adjustments to npm’s global installation permissions or executable PATH configuration.</p><p>Before packaging, ensure that the extension has been compiled and that its manifest contains a valid publisher identifier. This is also a good opportunity to review the project files and remove anything that should not be included in a public distribution.</p><p>From the extension’s root directory, run:</p><pre>vsce ls</pre><p>This displays the files that would be included in the package, allowing you to identify unnecessary build artifacts, local configuration, or sensitive files.</p><p>The .vscodeignore file can be used to exclude files that do not belong in the distributed extension. Take care not to exclude the compiled JavaScript output referenced by the manifest, since that code is required for the extension to execute.</p><p>Once the package contents are appropriate, create the VSIX:</p><pre>vsce package</pre><p>The resulting file will be named according to the extension identifier and version, such as:</p><pre>workspace-notes-0.0.1.vsix</pre><p>The package can be installed locally without publishing it to the Marketplace.</p><p>For example:</p><pre>code --install-extension workspace-notes-0.0.1.vsix</pre><p>The code command is available across Windows, macOS, and Linux, provided the Visual Studio Code command-line executable is configured in the terminal&#39;s PATH environment variable.</p><p>On Windows and many Linux installations, this is configured during installation. On macOS, it may need to be enabled manually by opening the Command Palette and running <strong>Shell Command: Install ‘code’ command in PATH</strong>, followed by restarting the terminal.</p><p>If the command is unavailable, the extension can still be installed without configuring the terminal. Open Visual Studio Code’s Extensions view, select the additional actions menu, choose <strong>Install from VSIX</strong>, and select the package generated by vsce package. This installation method is available through the editor&#39;s interface on all three desktop operating systems.</p><p>Installing the package locally provides another opportunity to test the actual distributed artifact rather than relying exclusively on the development environment.</p><p>This is an important distinction because packaging may reveal missing files, incorrect manifest paths, or assumptions that were satisfied by the original project directory but are not present in the distributed package.</p><h3>Publishing to the Visual Studio Marketplace</h3><p>Once the extension has been tested and packaged, it can be submitted to the Visual Studio Marketplace.</p><p>Publishing requires a publisher identity associated with the Marketplace. The publisher can represent an individual developer, organization, or brand, and its identifier becomes part of the extension’s Marketplace identity.</p><p>Visit the publisher management portal:</p><p><a href="https://marketplace.visualstudio.com/manage/publishers/">https://marketplace.visualstudio.com/manage/publishers/</a></p><p>Sign in with a Microsoft account and create a publisher if you do not already have one. Choose the publisher identifier carefully because Microsoft documents that it cannot be changed after creation.</p><p>Next, add that identifier to the extension’s package.json as the value of the publisher field.</p><p>For example, if the publisher identifier is examplepublisher, the relevant metadata would contain:</p><pre>{<br>  &quot;publisher&quot;: &quot;examplepublisher&quot;<br>}</pre><p>Replace the example identifier with your actual registered publisher ID. This fragment should be merged into the existing manifest rather than used as a replacement for it.</p><p>Rebuild and repackage the extension so the VSIX contains the correct publisher information.</p><p>For an initial release, one straightforward option is to upload the packaged VSIX through the Marketplace publisher management interface. This avoids requiring a developer to configure automated publishing before releasing a first extension.</p><p>The Marketplace validates the submitted package, and accepted extensions become available through their public listing once processing is complete.</p><p>Microsoft also supports publishing through the command-line interface using vsce publish. That approach becomes particularly useful for repeat releases and automated development pipelines.</p><p>Authentication requirements deserve attention here. Microsoft has announced the retirement of global Azure DevOps personal access tokens on December 1, 2026, and recommends Microsoft Entra ID-based authentication for secure automated publishing.</p><p>Developers planning a long-term release pipeline should consult the current publishing documentation rather than build new automation around credentials that are being retired.</p><p>For a first extension, manual publication provides a reasonable way to understand the release process before introducing continuous integration and deployment automation.</p><p>Official publishing documentation:</p><p><a href="https://code.visualstudio.com/api/working-with-extensions/publishing-extension">https://code.visualstudio.com/api/working-with-extensions/publishing-extension</a></p><h3>Maintaining the Extension After Release</h3><p>Publication marks the beginning of a different responsibility: maintaining software that other developers may install and depend upon.</p><p>Even a small extension needs attention when VS Code APIs evolve, dependencies require updates, or users encounter conditions that were not anticipated during development.</p><p>Versioning helps communicate changes over time. Visual Studio Code extensions use semantic version identifiers, commonly represented as major.minor.patch. The appropriate change depends on the nature of the release and its compatibility implications.</p><p>For example, a small correction to Workspace Notes might result in a patch release, while the introduction of substantially different capabilities could justify a larger version change.</p><p>Before releasing an update, compile the project, run relevant tests, examine package contents, and verify the resulting VSIX. These steps help prevent a seemingly minor update from introducing an unexpected regression.</p><p>User feedback can also provide valuable information about practical requirements. Someone may request a configurable filename, alternative Markdown templates, or support for additional workspace behaviors.</p><p>Not every feature request needs to become part of the product. A focused extension benefits from a clear purpose, and additional functionality should be evaluated according to whether it improves that purpose without introducing unnecessary complexity.</p><p>For Workspace Notes, possible future enhancements include user-defined file locations, reusable note templates, configurable section headings, and commands for inserting timestamps or task entries.</p><p>Each addition would introduce opportunities to work with other parts of the VS Code API while preserving the extension’s basic identity as a lightweight workspace utility.</p><h3>What Building an Extension Teaches You</h3><p>Developing a VS Code extension is a useful exercise because it brings together several areas of software engineering within a relatively manageable project.</p><p>The implementation itself introduces command registration, editor integration, filesystem interaction, asynchronous operations, and error handling. Testing demonstrates how the extension behaves inside the host application, while packaging highlights the importance of build artifacts, dependencies, and distribution metadata.</p><p>Publishing adds another dimension by requiring clear documentation, versioning, release preparation, and a plan for maintaining the software after others begin using it.</p><p>These responsibilities apply well beyond editor extensions. They are part of developing dependable software products more generally, even when the functionality being delivered is narrow.</p><p>There is also value in beginning with a relatively small problem. A developer does not need to create an elaborate AI assistant, full-featured productivity platform, or complex interface to produce a useful extension. Small utilities can provide meaningful improvements when they address recurring problems and integrate naturally into established workflows.</p><p>The accessibility of the extension platform makes it possible to experiment with those ideas, validate them through direct use, and distribute successful implementations without building a standalone application ecosystem.</p><p>Workspace Notes is intentionally modest, but it demonstrates a complete development journey: identifying an inconvenience, defining a focused solution, implementing it through the VS Code API, validating its behavior, and preparing it for public distribution.</p><p>For developers interested in creating their own tooling, that experience is often a more valuable starting point than immediately pursuing a larger project. Once the extension lifecycle is understood, the same foundation can support increasingly specialized utilities, richer interfaces, and more sophisticated integrations.</p><h3>Further Reading</h3><p><strong>Visual Studio Code — Your First Extension</strong></p><p><a href="https://code.visualstudio.com/api/get-started/your-first-extension">https://code.visualstudio.com/api/get-started/your-first-extension</a></p><p>Official walkthrough covering extension scaffolding, activation, development, and debugging.</p><p><strong>Visual Studio Code — Extension API</strong></p><p><a href="https://code.visualstudio.com/api">https://code.visualstudio.com/api</a></p><p>API reference and documentation covering the editor’s extensibility model, available APIs, and supported contribution points.</p><p><strong>Visual Studio Code — Extension Manifest</strong></p><p><a href="https://code.visualstudio.com/api/references/extension-manifest">https://code.visualstudio.com/api/references/extension-manifest</a></p><p>Reference for the package.json metadata and configuration fields used to define an extension.</p><p><strong>Visual Studio Code — Virtual Workspaces</strong></p><p><a href="https://code.visualstudio.com/api/extension-guides/virtual-workspaces">https://code.visualstudio.com/api/extension-guides/virtual-workspaces</a></p><p>Guidance on using workspace filesystem abstractions, handling virtual resources, and developing extensions that work appropriately with different workspace providers.</p><p><strong>Visual Studio Code — Publishing Extensions</strong></p><p><a href="https://code.visualstudio.com/api/working-with-extensions/publishing-extension">https://code.visualstudio.com/api/working-with-extensions/publishing-extension</a></p><p>Official instructions for VSIX packaging, publisher registration, Marketplace distribution, and release management.</p><p><strong>Visual Studio Code — Extension Samples</strong></p><p><a href="https://github.com/microsoft/vscode-extension-samples">https://github.com/microsoft/vscode-extension-samples</a></p><p>Microsoft’s collection of reference implementations demonstrating different extension APIs and development patterns.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=986f0bc5614f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Meet Curious Explorer: A New Personality for Microduck]]></title>
            <link>https://medium.com/@bryan.pesquera/meet-curious-explorer-a-new-personality-for-microduck-ae129329bc5f?source=rss-151df39fd664------2</link>
            <guid isPermaLink="false">https://medium.com/p/ae129329bc5f</guid>
            <category><![CDATA[robotics]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[microduck]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[open-source]]></category>
            <dc:creator><![CDATA[Bryan Pesquera]]></dc:creator>
            <pubDate>Wed, 28 Oct 2026 14:11:02 GMT</pubDate>
            <atom:updated>2026-10-28T14:11:02.380Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Aticmm0NlvOI0CO1mjWISQ.png" /><figcaption>Concept illustration of Curious Explorer, a new Microduck personality designed around curiosity, expressive movement, and small discoveries.</figcaption></figure><p><em>I’m building a collection of personalities for Microduck, starting with a curious little explorer. It turns out that making a robot feel like a character involves a lot more than making it move.</em></p><p>I’ve been thinking about what would make someone genuinely enjoy having a robot around. Not for the first five minutes, when almost anything a small robot does is entertaining, but weeks or months later, when it’s become another familiar object in the house. The novelty of watching it walk around, turn its head, or perform a clever trick would eventually wear off. What would remain is its behavior, the little things it does without being asked, how it responds to its surroundings, and perhaps most importantly, whether it knows when to leave you alone.</p><p>That’s what got me interested in giving robots personalities. I’ve always liked the idea of machines having recognizable characteristics, not necessarily because they’re intelligent in the way we generally understand intelligence, but because consistent behavior can make something feel familiar. We already form attachments to fictional characters whose personalities are expressed through relatively predictable patterns. I started wondering whether a small physical robot could create something similar through movement, attention, and timing.</p><p>The robot I’ve been exploring is <a href="https://pollen-robotics.com/microduck/">Microduck, a small open robotics project from Pollen Robotics and Hugging Face</a>. I don’t actually own a physical Microduck yet, but the available software and simulation environment have given me somewhere to start experimenting. Rather than immediately trying to build a sophisticated autonomous system, I decided to approach the problem from a different direction: what if someone could choose a personality for their robot, install it alongside the existing software, and gradually become familiar with that particular character?</p><p>The idea is to create a collection of distinct personalities, each with its own temperament, preferences, and patterns of behavior. One might be curious and adventurous, another reserved and observant, and another more energetic and playful. I don’t want these differences to be limited to a name or a few predetermined animations. Ideally, choosing a personality would meaningfully change how the robot behaves throughout the day, while still allowing its owner to control it and use the features they’ve already installed.</p><p>I’ve started building the first of these characters, which I’ve named <a href="https://github.com/hidrogencloride/microduck-curious-explorer">Curious Explorer</a>.</p><h3>A Little Curiosity Goes a Long Way</h3><p>Curious Explorer is intended to be an observant, patient, and quietly playful character with an interest in small discoveries. I imagine it noticing something nearby, taking a moment to investigate, perhaps tilting its head as if considering what it’s looking at, and eventually moving on. It shouldn’t constantly demand attention or react dramatically to everything around it. Part of the personality I want to create comes from the moments when it isn’t doing very much at all.</p><p>Its motto is “Small discoveries. Great company,” which has become a surprisingly useful way to evaluate the behavior I’m designing. When I’m considering whether to introduce a new action or reaction, I try to ask whether it actually fits that description. A character that interrupts constantly, moves erratically, or reacts to every observation with the same enthusiasm wouldn’t feel particularly patient or thoughtful, regardless of how appealing its animations might be.</p><p>That has led me to think about personality as something that emerges from a collection of smaller behavioral decisions. How quickly should Explorer respond to something unfamiliar? How long should it remain interested? Should it approach immediately or spend a moment looking first? What happens when there’s nothing interesting to investigate? The answers need to be reasonably consistent, because that’s how I expect a recognizable character to develop over time.</p><p>For the first implementation, I’m keeping these decisions explicit. Explorer currently uses a behavior layer that translates supplied observations into movement intentions and other permitted actions. It doesn’t use a language model, hold conversations, or interpret its surroundings through a camera. Those are capabilities I may explore later, but I wanted to establish a predictable behavioral foundation before adding more complicated forms of perception or interaction.</p><p>For now, the observations used during testing are scripted. That means I can control the circumstances under which Explorer is expected to respond and examine whether the resulting behavior matches what I intended. It’s a fairly modest starting point, but it allows me to work on the character’s consistency without confusing personality design with the much larger challenge of autonomous perception.</p><h3>A Personality Shouldn’t Take Over Your Robot</h3><p>One requirement I’ve been particularly concerned about is making sure these personalities work alongside the software someone already has installed.</p><p>Microduck is an open platform, and part of its appeal is that people can experiment with its capabilities, modify its behavior, and develop their own software. Someone might spend considerable time configuring their robot, installing additional skills, or developing custom controls. I don’t think adding a personality should mean giving any of that up.</p><p>My intention is for Curious Explorer to function as an additional behavioral layer rather than a replacement for the robot’s existing capabilities. It should be able to request compatible actions when appropriate, but only when those actions are actually available and permitted. If a particular gesture or skill isn’t supported, the character should adapt its response rather than attempt to install or modify something without the owner’s knowledge.</p><p>The current experimental connector reflects those boundaries. It doesn’t provide operations for installing, replacing, or deleting skills, and it doesn’t modify controller configurations or walking policies. Those restrictions don’t automatically solve every compatibility problem, particularly when multiple systems might want to control the robot simultaneously, but they establish an important starting point.</p><p>I’ve documented the current assumptions and limitations in the project’s <a href="https://github.com/hidrogencloride/microduck-curious-explorer/blob/main/docs/compatibility.md">compatibility notes</a>. The eventual goal is for a personality to feel like a welcome addition to the robot, rather than something that takes ownership of it.</p><h3>My First Explorer Barely Explored Anything</h3><p>Once I had the initial behavior layer working, I started integrating it with the <a href="https://huggingface.co/spaces/pollen-robotics/microduck-simulator">official Microduck Sandbox</a>. This gave me a way to observe the character’s movement requests using the simulator’s existing physics and walking policy, without needing to modify the underlying movement system.</p><p>The first meaningful problem I encountered was almost comical. I had designed Explorer to move gently and deliberately, which seemed appropriate for a patient little character. Unfortunately, the walking speed I requested was so low that the simulated duck barely moved at all.</p><p>From the behavior layer’s perspective, everything looked reasonable. Explorer had decided to investigate something, issued a movement request, and waited for the next part of its routine. Visually, however, there was very little exploration happening. I had effectively created a character with somewhere to go and almost no ability to get there.</p><p>I initially wanted to know whether the problem was in my integration or simply how the existing walking policy responded to lower movement requests. To investigate, I compared the adapter’s output against the sandbox’s normal keyboard controls under similar conditions. When both used the same walking command, they produced nearly identical displacement. At the much lower requested speed, movement was almost nonexistent.</p><p>That told me the integration was reaching the correct movement system, but my assumptions about how the simulated duck would respond to a gentle velocity request weren’t particularly useful. I introduced a simulator-specific movement profile that maps exploratory steps to a command the existing walking policy can execute more reliably, while retaining the shorter movement durations and stopping behavior that I wanted for the character.</p><p>I also adjusted the timing to follow the simulation clock rather than relying on ordinary elapsed time. That distinction matters when testing movement in a browser, because rendering performance and simulation progress don’t necessarily advance at the same rate. A behavioral action intended to last a particular amount of simulated time needs to remain consistent even when the browser runs more slowly.</p><p>After those changes, Explorer finally started going somewhere.</p><p>Two short, calibrated simulation runs reached maximum displacements of approximately 18 and 21 centimeters from their respective starting positions. That might be one of the least impressive exploration records ever recorded, but it was a meaningful result for what I was testing. The duck was responding to the character’s movement requests through the existing walking policy, and I could reproduce and measure what happened.</p><p>Those runs also exercised scripted obstacle events, stopping, pausing, and resuming. I separately tested manual keyboard input to confirm that Explorer would yield control when the owner intervened and remain paused afterward. The simulator’s loaded walking policy objects were left unchanged.</p><p>The project currently has 50 passing automated tests, and I’ve published the <a href="https://github.com/hidrogencloride/microduck-curious-explorer/blob/main/docs/sandbox-testing.md">sandbox setup instructions and recorded results</a> for anyone who wants to examine or reproduce the work.</p><p>What I found interesting about this experience was how directly an implementation detail affected the personality I was trying to create. A character that barely moves when it intends to explore doesn’t feel particularly curious, regardless of how carefully its decision-making rules are written. At the same time, simply increasing its movement speed without considering timing could make it feel hurried or restless. The engineering and character design aren’t separate concerns. They continuously influence one another.</p><h3>Making Something Feel Alive Without Pretending It Is</h3><p>I think there’s an interesting distinction between designing a robot that appears intelligent and designing one that has a recognizable personality.</p><p>A conversational system can generate elaborate responses, remember previous exchanges, and adapt its language to the person using it. Those abilities can create an impression of personality, but they aren’t the only way to establish one. Animated characters have communicated temperament through movement and timing for generations, often without saying very much at all. I suspect some of those same principles could be useful in small companion robots.</p><p>A slight hesitation before approaching something, a repeated preference for certain behaviors, or a tendency to remain quietly observant could become recognizable characteristics if they’re implemented consistently. They don’t require the robot to experience curiosity or understand the world as a person does. They require the behavior to be coherent enough that an observer begins to develop expectations about it.</p><p>Of course, there’s a difference between imagining how these characteristics might feel and demonstrating that they actually work. Explorer is still an early software project, and the current simulation doesn’t provide real environmental perception. A scripted obstacle event is not evidence of obstacle recognition, and watching the simulated robot move doesn’t tell me how convincing the same behavior will be on physical hardware.</p><p>I also haven’t built the finished persona installation experience yet. The public repository currently contains development source, documentation, automated tests, and a reproducible sandbox integration. It isn’t an application that someone can download today and install as a complete personality on their Microduck.</p><p>I’m being deliberate about those distinctions because the eventual character experience depends on more than whether the software produces a charming demonstration. It needs to be reliable, compatible with the robot’s existing capabilities, and predictable when its owner wants to interrupt or disable it.</p><h3>One Duck, Many Possible Personalities</h3><p>Curious Explorer is intended to be the first character in a broader collection, although I’m resisting the temptation to announce a long lineup before there’s meaningful behavior behind each personality.</p><p>I can imagine several different directions for future characters. Some might be more inclined to investigate their surroundings, while others could prefer remaining nearby and responding occasionally to activity. There are interesting possibilities around movement, gestures, attention, and the way a character responds to familiar situations. I would like each one to have enough consistency that choosing between them feels like a genuine preference rather than selecting a cosmetic variation.</p><p>The experience I’m working toward is relatively straightforward. Someone could browse a collection of personalities, find one that appeals to them, and add it to their robot without disturbing their existing configuration. Over time, that character’s habits would become familiar. If they wanted something different, they could eventually switch to another personality or remove the one they had installed.</p><p>There’s still considerable work between that idea and a finished product. My next technical priority is validating the Python connector against the official robot-daemon simulator, followed by testing on physical hardware once I have a Microduck available. I also need to work through supported installation, updates, removal, and interactions with other software. Those aren’t particularly glamorous features, but I consider them essential if the project is going to become something people can actually use.</p><p>For now, I’m enjoying the process of figuring out how much personality can emerge from relatively simple behavioral choices. I started this project because I liked the idea of a robot having a character of its own, but developing Explorer has made me more interested in the smaller details that make that character recognizable. Even something as ordinary as deciding when to take a few steps, when to look around, and when to remain still becomes part of the experience.</p><p>The <a href="https://github.com/hidrogencloride/microduck-curious-explorer">Curious Explorer source code is available on GitHub</a>, along with the documentation and simulation tests. I’ve also <a href="https://github.com/joeynyc/awesome-microduck/pull/33">submitted the project to Awesome Microduck</a> for community discovery, where the submission is currently awaiting review. Anyone interested in the development can explore the repository, reproduce the sandbox results, or follow along as I work toward the first installable version.</p><p>I’m curious to see whether these characters can eventually become something more memorable than a collection of robotic movements. There’s something appealing about the idea of two people owning exactly the same robot, running different personalities, and describing them as though they have entirely different temperaments.</p><p>For now, mine has managed about twenty centimeters of exploration in a simulated environment. It isn’t much, but I already have a fairly clear idea of the kind of little character I want those steps to become.</p><p><em>Curious Explorer is an independent community project by hidrogencloride and is not affiliated with Pollen Robotics, Hugging Face, or NVIDIA.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ae129329bc5f" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>