Towards AI-Native UXR: Field Notes 1
A working list of what I’ve been reading and watching to understand LLMs and agents on before folding it into my UX research practice.
Welcome to a new, recurring thread inside Signals to Solutions: “Towards AI-Native UXR: Field Notes.” Think of it less as a syllabus and more as a running record of what I’ve actually been reading and watching to become AI-native as a UX researcher.
This first entry has two goals, both before any UXR application of AI-assisted coding tools: understanding how the models and agents I rely on actually work (not just how to prompt them well), and being able to understand some popular concepts in practically using these tools to build things. Folding this foundational knowledge into research practice will be its own Field Note, and it’s coming in the future.
My take
From my viewpoint, being AI-native isn’t a certificate you finish. It’s more like a habit, staying curious as the ground keeps shifting under you. With the current speed of AI development, a model’s architecture, its limits, and the vocabulary practitioners use will all look different in six months. Waiting for the field to hold still isn’t a strategy, so the habit I’m actually building is smaller and more durable than any one tool or paper: learn enough to form your own judgment, build something small enough to test that judgment against reality, then let curiosity pull you toward whatever question comes next.
Everything below is what that’s looked like so far for me. This is a non-exhaustive list of resources I have been reading and watching to get more familiar with LLMs and AI agents. I have to also state that I am no expert in this field, just a very curious UX researcher learning this and seeing how to adopt it in my own line of work.
Essential lessons from a classroom
Free online courses from top universities are a gold mine here. So I started with watching some of the Stanford Online courses from 2025 and 2026, which are closer to our era in time. It teaches foundational understanding on Deep Learning, LLMs and AI Agents, all from brilliant experts in the field. This gives me a good understanding of how LLMs and AI Agents are trained, how they are improved, and most importantly, where their essential limitations lie. Take a look here is you feel like it:
Stanford Online, CS230: Deep Learning (full course) — the foundations that LLMs are built on: neural networks, how models are trained, core deep-learning ideas.
Stanford Online, CS329A: Self-Improving AI Agents (full course) — a clear opening lecture on how modern agents use tools, verify themselves, and improve from feedback.
Essential papers on LLM phenomena
Most people’s first real contact with LLMs is through prompting, and I think that’s a genuinely useful skill worth developing. But it teaches you almost nothing about why a certain phrasing works, why a model breezes through a short task and unravels on a long one, or what’s actually happening when a system seems to “reason” instead of just answering.
Underneath prompting sits an actual arc of research on LLM phenomena that I find useful in understanding. So here is a short list of selected papers I have been digging into. First: about a LLM’s architecture. Then: proof that scaling it up produces genuinely new capabilities. Then embedded two techniques, one for making reasoning visible, one for making a model act in the world through tools. And then a useful paper about where that architecture still struggles. This is the arc of papers that I started with, and the papers are listed in that order below.
Select papers listed in sequence:
Vaswani et al. (2017), Attention Is All You Need — the paper that introduced the transformer, the architecture behind every modern LLM. Dense, but the single most load-bearing paper in the field.
Brown et al. (2020), Language Models are Few-Shot Learners — the GPT-3 paper, and the empirical case that scaling a transformer up produces real new capabilities rather than just a better version of the same thing.
Wei et al. (2022), Chain-of-Thought Prompting Elicits Reasoning in Large Language Models — shows that asking a model to reason step by step measurably improves its answers, and underlies most modern prompting technique.
Yao et al. (2022), ReAct: Synergizing Reasoning and Acting in Language Models — defines the reason-then-act loop underneath most modern AI agents.
Liu et al. (2023), Lost in the Middle: How Language Models Use Long Contexts — models are far better at using information at the start or end of a long context than information buried in the middle, a finding that directly shapes how context is actually structured in practice.
The vocabulary for building with AI keeps expanding
Every couple of weeks, we hear of a new term for AI coding pop up, such as Prompt Engineering and Context Engineering. And these techniques build on top of each other, expanding what users can do if they engineer their AI systems that way. Each one wraps the layer that came before it, rather than replacing it. So it appears that this string of development has it’s own expanding set of vocabulary now. It’s worth learning, because it’s a real skill for building effectively with AI. Below is the ladder as it stands today:
The AI coding engineering ladder, in order:
Prompt engineering — crafting the instruction itself, so a single request reliably gets you the output you want.
Context engineering — curating everything the model can see: memory, tool outputs, retrieved documents.
Harness engineering — designing the scaffolding around the model (e.g., tools, permissions, feedback, verification) that makes an agent reliable, independent of the model itself.
Loop engineering — designing the agentic loop itself: how an agent iterates toward a goal, checking and correcting its own work with minimal intervention.
Graph engineering — traces graph engineering’s lineage back through dataflow architectures and multi-agent systems research, rather than treating it as a brand-new idea.
Apart from AI coding engineering techniques, here are also some sources on practical primers of building with AI, including guides from Anthropic and experts in the field:
Practice primers:
Anthropic, Building Effective Agents — the clearest plain-English primer on what an agent actually is and when to reach for one instead of a simpler workflow.
Anthropic, Introducing the Model Context Protocol — the open standard for connecting models to tools and data, and increasingly how agents plug into the real world.
Simon Willison, Here’s how I use LLMs to help me write code — a working engineer’s honest, concrete account of what actually works and where it doesn’t.
Gergely Orosz, Building Claude Code with Boris Cherny — a firsthand look at how Claude Code’s creator actually codes day to day, running five parallel Claude instances and letting a solid plan one-shot the implementation.
Where this leaves off
In Field Notes, everything mentioned is just a take on how I approach learning to become an AI-native UX researcher. And for the first piece to this series, everything listed above is a foundation, not yet an application. The goal is to set up the needed understanding of how the AI systems work, as well as the essential vocabulary around it. Also, none of this is settled. As new research and use cases of AI emerge, new papers will complicate parts of the arc above, the engineering ladder will probably grow, and some of these links might feel dated in a couple of months. So take this as a starting point. As I like to think about it, just learn enough to form your own judgment, build something small enough to test, and let curiosity pull you toward whatever comes next. It’s an ongoing journey, like an expedition, and that’s why I am writing Field Notes.
This is a personal, non-exhaustive list of topics; not a definitive curriculum for becoming AI-native. It reflects what I’ve been reading and watching as of this writing, and it is the first in an ongoing series. I am always open to discussions and sharings from others of their own learning journeys, so feel free to reach out in the comments!
留言