artificial-intelligence

AI-Assisted Gaming: A New Dimension in Gameplay

The concept of automated agents in games has been around since the beginning of video gaming. From chess bots to difficulty settings and computer-controlled opponents, these systems have always been part of how games are designed and played. Traditionally, these agents served robotic, automated purposes, following pre-programmed rules to either challenge the player or add complexity to the game environment.

AI-assisted gaming, however, goes one step further. This emerging genre shifts these systems away from being simple opponents or automated mechanics and transforms them into collaborative partners. In these games, the agent acts as a teammate, sidekick, or co-player—creating the sensation of gaming alongside another real person.

In action RPGs, for example, you might have an agent playing alongside you as though it were another player. You can build the agent’s character just like you would your own, providing instructions and feedback on how it plays. Over time, it learns and adapts based on playing with you, evolving into a personalized companion that complements your strengths and supports your strategies.

This fundamentally changes gaming experiences, especially in single-player games. AI-assisted games introduce tactics, builds, and strategies that were previously only possible in multiplayer settings, bringing new approaches to mastering games and exploring creative playstyles. It opens up exciting new dimensions for single-player games, making them feel less solitary and more dynamic.

What’s even more exciting is that this concept can be adapted to nearly any type of game. Whether it’s action, puzzle, RPG, or strategy, the specific approach will depend on the genre, but the application of AI-assisted features can enhance gameplay across the spectrum. For example, agents could act as co-strategists in a tactical game or assist with solving puzzles in a cerebral adventure.

AI-assisted gaming represents a significant leap forward for the medium. By transforming computer-driven agents into collaborative, learning companions, developers are creating more immersive and innovative gaming experiences that expand what players can achieve in both solo and cooperative play.

Object-Oriented Programming a Failed Abstraction

Object-oriented programming (OOP) is built on abstraction, encapsulating both data and behavior into “objects.” While this approach has dominated software development for years, it doesn’t always align with how programs are created and executed. Often, the abstractions OOP introduces feel mismatched with the dynamic nature of software design and operation.

A key problem lies in how OOP connects data and operations. Take the example of a “person” object in a system. Attempting to define everything a person can do or be involved in within a single object quickly becomes impractical. People interact with systems in countless ways, such as being members of different groups, triggering workflows, or being part of external processes. Trying to encapsulate all these interactions within one abstraction leads to unnecessary complexity and rigidity. Software is not inherently about “things” or “objects”—it’s about tasks, processes, and services.

Much of software development is process-oriented. Applications often center around actions that need to be performed, such as validating business logic, fetching data, or completing a workflow. Similarly, functional programming approaches emphasize operations acting on data rather than tightly coupling both into objects. These paradigms reflect an underlying truth: software is primarily about what happens, not static representations of entities.

Thinking about software as “something that happens” can lead to cleaner, more practical designs. Programs are dynamic systems where tasks unfold over time based on input, rules, and workflows. By focusing on what needs to be done rather than forcing abstractions into objects, developers can design systems that align more closely with how software actually operates.

This doesn’t mean abandoning object-oriented programming entirely. OOP can be useful when modeling concepts with clear boundaries and well-defined behaviors, but it’s important to recognize that abstractions based on static objects are not always the best fit. Often, process-oriented thinking offers a simpler and more scalable solution, especially when software revolves around actions rather than entities.

Developers don’t need to follow a rigid paradigm, but rethinking abstractions can lead to better decisions. Software is dynamic, and understanding it as tasks, processes, and workflows rather than a collection of objects can help developers create more practical and adaptable solutions.

Short-term planning loop

Short-term planning loop is the most basic decision-making and thought process for a language model or agent. It is based on iterative thinking, where the agent continuously evaluates its progress and adjusts its actions as needed to move closer to achieving its goal. This looping pattern is simple yet highly effective for short-term problem-solving.

At the core of the loop is the agent’s continuous cycling of actions, evaluations, and adjustments—commonly referred to as agent loops. After an initial action is taken, the agent performs a review to assess the current state or outcome of the actions. This review involves analyzing what worked, what didn’t, and identifying areas for improvement. Reflection is critical during this stage, as it reveals valuable insights that inform the next steps.

The next step in the loop is to evaluate how far the agent is from the goal. This requires examining the gap between the current state and the desired result. It’s about identifying how much progress has been made and where effort still needs to be directed. By understanding this distance, the agent can focus its attention on the most impactful areas for change.

Based on the review and evaluation, the agent adapts its approach, refining actions as needed. From here, the cycle begins anew, with fresh adjustments driving each new iteration. This ability to consistently assess and modify actions allows the agent to respond effectively to challenges while steadily moving toward the goal. This process of adjust and repeat is a core part of the loop and ensures continual progress.

The short-term planning loop is useful not only for advancing the functionality of agents but also as a practical tool for everyday decision-making. Whether it’s managing personal tasks, solving problems, or completing a project, this loop can help achieve better results through repeated cycles of evaluation and improvement.

The benefits of this framework are clear. It provides a simple way to track progress, stay focused on short-term goals, and adapt as needed to changing circumstances. By emphasizing iterative action and measured adjustments, the short-term planning loop brings clarity and structure to the decision-making process. Its straightforward nature makes it accessible for both digital agents and individuals who want a practical strategy for tackling their objectives.

Understanding the Strengths and Risks of Language Models

Language models have proven themselves as masters in creating text that seems polished and professional. They are extraordinarily good at appearing competent in their outputs, crafting persuasive responses, and even taking on roles within creative or professional scenarios like actors in a play. These qualities make them incredibly versatile tools for tasks such as storytelling, content creation, and communication.

However, much of their strength lies in their ability to imitate. Language models excel at mimicking reality, generating responses that can feel authentic and convincing. Yet, this skill of “pretending” can be deceptive. While their outputs can seem well-informed, it’s essential to remember that they lack genuine understanding. They generate text based on patterns learned from vast datasets, and their confidence can mask a lack of true comprehension.

This ability to imitate creates a potential pitfall. When relying too much on outputs from these tools, it’s easy to let personal beliefs, hopes, and expectations interfere with judgment. If users treat these suggestions as truths or infallible answers, there’s a risk of misusing them, whether in critical decision-making or emotional reasoning. Humans may inadvertently project their own intentions onto the tool and end up in a trap of unwarranted trust.

The key to avoiding these risks is approaching language models with a critical mindset. What they produce should be seen as helpful hints, not unquestionable facts. Fact-check their results, consult other resources, and always pair their outputs with human expertise. Their value lies in how we choose to use them—when complemented with careful analysis and application, they can be truly transformative tools.

Language models are powerful but are not substitutes for human understanding. Their role is best appreciated when we recognize their strengths as well as their inherent limitations, ensuring that our use of them remains purposeful, thoughtful, and effective.

How AI apps work

When you ask a question in an app, it might feel like you’re interacting with an expert who knows everything. In reality, there’s a structured process behind the scenes that organizes existing information into a useful response. Let’s break down how these apps work.

The journey begins when you type in your question. The app uses a Small Language Model to extract key terms from your query—essentially identifying the main ideas or keywords. These keywords are then used to perform a regular search engine query on platforms like Google or Bing. The search results are processed by the app, which evaluates summaries of the top 100 hits using another Small Language Model to rank the 10 most relevant pages.

Next, the app crawls the content of those 10 pages, pulling in the most relevant material. This content is combined with your original question to create a detailed context. Finally, this context is sent to a Large Language Model, which generates a polished response that feels complete and confident—almost as if the app itself “knew” the answer.

Though this process may seem intelligent, it’s simply an optimized way of finding, filtering, and presenting information. The system doesn’t actually “know” anything; instead, it mimics understanding by repackaging existing knowledge.

These apps provide a valuable service by streamlining searches. Instead of sifting through endless links yourself, they consolidate information into a single, user-friendly response. This can save time and help with tasks such as brainstorming ideas, summarizing research, or finding information quickly.

Still, there are limitations. The quality of the response depends entirely on the data available and how the app ranks relevance. It’s always worth verifying critical information, as the system may miss nuances or context that you’d notice when manually researching.

Ultimately, language model-powered apps are useful tools that make information easier to access and process. They don’t provide true intelligence, but they can be an efficient way to search, summarize, and communicate ideas. Use them for what they’re good at, and stay thoughtful when evaluating results.

The Future of Domain-Specific Apps: Who Will Shape the Landscape?

App developers are busy leveraging advanced tools, such as language models, to revolutionize the way they build domain-specific applications. These tools are helping improve coding, testing, documentation, security, and general software engineering processes, making app development faster, more efficient, and more reliable. Developers focus on creating scalable, secure, and technically robust applications that meet high standards and long-term needs. However, they often face challenges in deeply understanding the unique requirements and workflows of specific domains.

At the same time, domain experts are bypassing developers altogether to build their own applications. Equipped with deep knowledge of their fields and a clear understanding of what works and what they want, these professionals are creating solutions tuned specifically to their needs. They care about functionality and outcomes, not about how the underlying code is written. Thanks to the rise of user-friendly tools, such as no-code and low-code platforms, they can build apps quickly without relying on software development teams. While their solutions are practical and tailored, they can face limitations in areas like scalability, security, and technical refinement.

This divide between app developers and domain experts raises an important question. Who will take the lead in shaping domain-specific apps? Will app developers prevail with their technical precision and ability to scale solutions? Will domain experts win through their intimate knowledge of what matters in their industries? Or perhaps the future belongs to those who can do both—combining software engineering expertise with domain insight to bridge the gap.

The most promising path forward may lie in collaboration. When app developers and domain experts work together, they can create applications that combine technical robustness with tailored functionality. App developers can help build solid infrastructures, while domain experts provide the insights needed to create tools that truly solve practical problems. Another possibility is the emergence of hybrid creators—individuals skilled in both software development and domain-specific knowledge, capable of weaving together the strengths of both groups.

Rather than focusing on which group “wins,” the future of domain-specific apps is about leveraging the best of both worlds. Innovation will thrive when technical expertise and domain knowledge come together, ensuring apps can meet immediate needs while remaining scalable, secure, and impactful over time. The opportunities are immense, and success belongs to those willing to embrace collaboration or develop hybrid approaches that serve both technical and domain goals.

The Importance of Formatting in Code for Readability and Quality Assurance

Writing code that is clear and easy to understand is a fundamental goal in software development. Readable code allows developers to quickly grasp its purpose, evaluate its quality, and make improvements. This becomes especially critical when working with generated code, where much of the effort goes into reading, understanding, and quality-assuring what is produced, rather than writing it from scratch.

Despite this, formatting features that aid comprehension are often absent in code. There is little support for techniques like using line breaks to separate logical sections or indentation to show hierarchy and flow. Code does not allow for visual tools like highlighting or underlining to emphasize important elements. It lacks paragraph-like divisions to separate ideas and often doesn’t include clear headings or structured sections that help navigate larger chunks of work.

These missing formatting features are easy to take for granted in other forms of writing, such as documents or articles. In those contexts, they play a significant role in organizing content and guiding the reader. Without similar support in code, developers are left to navigate dense, unstructured blocks of text, making the process of understanding much more tedious.

This problem is amplified with generated code. Developers working with generated code often spend the majority of their time trying to read and understand it. Poor formatting adds unnecessary complexity, slowing down tasks like debugging, quality assurance, and feature development. More structured formatting would make generated code easier to interpret, reducing the time and effort required to work with it effectively.

By applying principles of formatting to code—such as better use of spacing, structure, and visual cues—developers can make their work less about deciphering and more about solving problems. Thoughtful formatting isn’t just about aesthetics; it’s about creating an environment where developers can focus on what truly matters, whether they’re writing code or working with what has been generated.

Stories That Add Context

Effectively training language models starts with high-quality, structured data. For a model to truly learn and apply knowledge, it needs consistent, reliable data that forms the foundation of its understanding. Quality data enables the model to build connections and recognize how different pieces of information fit together. Beyond raw data, providing the model with context is essential. One effective method is to use stories that frame the information in a way that makes it relatable and meaningful.

Creating good stories involves adding a wealth of related details while staying grounded in structured data. These stories help the model understand not just isolated facts but the broader context they belong to. For example, in the field of healthcare, structured data about treatments can be used to craft narratives about how specific symptoms led to particular diagnoses and treatments. These stories provide the model with insights into the interconnected nature of medical knowledge, teaching it how symptoms, processes, and outcomes relate to each other.

Such contextualized stories play an important role in helping the model learn how knowledge fits into larger systems and how it can be used. Instead of limiting itself to memorizing terms or concepts in isolation, the model gains a deeper understanding of how information interacts in real-world applications. This makes it better at adapting its responses to practical scenarios, like answering complex questions or solving problems where context is key.

When models are trained using detailed stories from structured data, particularly in specialized areas like healthcare, their ability to apply knowledge improves significantly. These stories not only enhance learning—they also prepare the model to make informed, context-aware decisions that are closer to how humans approach complex issues. Crafting narratives from structured data is a powerful way to unlock the full potential of language models and bring out their utility in a meaningful and impactful way.

Navigating Levels of Abstraction in Knowledge Work

In knowledge work, understanding the level of abstraction you’re operating on can make all the difference. A famous example helps illustrate the concept: “This is a picture of a painting of a painting of a pipe.” At the simplest level, we have the concrete—the pipe itself. Beyond that, we move to representations: the painting of the pipe, which is one level removed, and then the painting of the painting, which adds yet another layer of abstraction.

The concrete level is the easiest to grasp—it’s direct and tangible. However, the higher levels of abstraction, those that deal with representations of representations or broader conceptual thinking, are harder to understand and often tricky to apply appropriately. Knowing when and how to move beyond the concrete level is a skill, one that isn’t always intuitive.

Humans and language models alike face challenges in handling abstraction. We can easily mix up the layers, treating abstract representations as if they were concrete objects. Some individuals and systems struggle to work beyond the concrete level at all, sticking only to the simplest, most tangible concepts. This can lead to oversimplified results when the task or concept at hand requires more nuanced thinking across abstract layers.

These difficulties also create challenges for building tools that support knowledge work. Tools must be designed to navigate and present information at multiple levels of abstraction, making them both accessible and capable of handling complexity. This is especially vital when creating systems or agents intended to work alongside humans, as their ability to handle abstraction impacts their usefulness and relevance in knowledge-intensive tasks.

Understanding levels of abstraction isn’t just a theoretical exercise—it’s an essential skill for working smarter. By recognizing these layers and the challenges they bring, we can design better tools, make better decisions, and approach problems with greater clarity. Mastering abstraction enables us to connect the concrete with the conceptual, leading to more effective knowledge work overall.

Does the Quality of Language Model Output Reflect User Competence?

Language models are becoming widely used for tasks like writing, brainstorming ideas, or solving problems. However, the quality of their output can vary significantly from user to user. Some report achieving results that are almost perfect and consistently reliable, while others experience chaotic, low-quality attempts that fall far short of their expectations. This wide range of outcomes raises an interesting question: does the competence of the user directly impact the quality of the outputs from a language model?

The competence of a user seems to be an important factor. A skilled user often knows how to craft a clear and precise prompt, provide enough context, and refine the model’s responses until they reach their desired result. In contrast, less experienced users might write vague, unclear, or overly broad instructions, which can lead to results that feel like a poor imitation of what they wanted. Essentially, the quality of the output often reflects the probability of the user producing high-quality results on their own.

Getting reliable and consistent results requires understanding how to effectively interact with a language model. Competent users tend to excel because they treat the model like a collaborator, shaping and guiding its output step by step. For example, they might clarify their request with specific formats, break complex tasks into smaller parts, or offer examples of what they’re looking for. Meanwhile, users who don’t have this approach sometimes struggle to communicate their needs or expect the model to “read their mind.”

The good news is that any user can improve their ability to work with language models over time. By becoming more deliberate in their process—rewriting prompts for better clarity, breaking tasks into smaller steps, or providing examples—they will often see improvements in the results. Experimentation is key, as is the patience to refine the interaction instead of expecting perfection on the first try. Whether experienced or not, the effort users put into guiding the model can ultimately make all the difference.

The relationship between user competence and output quality highlights that these tools are bridges rather than shortcuts. They are only as effective as the guidance they are given, and even users starting at a low level can learn to achieve better outcomes with practice. Familiarity with how to communicate with language models unlocks their true potential, allowing anyone to move closer to achieving near-perfect results.