# Cursor Chat: ai-agent-book

## Metadata
- **Project**: ai-agent-book
- **Path**: `/Users/boj`
- **Date**: 2025-09-17 14:06:38
- **Session ID**: `67be8d8d-2083-4b6c-8426-71f98d9c65c0`

## Conversation

### 👤 You

@https://arxiv.org/pdf/2507.16003 

认真阅读这篇论文中 ICL 相当于是 low-rank update 的观点，然后仔细阅读并修改第二章，在合适的段落和小结处，加入这篇论文的观点，以及加入我的观点：user memory 事实上是利用更多算力对上下文中的关键信息进行提取，得到一种更简洁、更结构化的知识表达，从而使后续的对话便于更高效利用这些知识（这些观点不一定放在一起）


Learning without training:
The implicit dynamics of in-context learning
Benoit Dherin∗
Google Research
dherin@google.com
Michael Munn∗
Google Research
munn@google.com
Hanna Mazzawi∗
Google Research
mazzawi@google.com
Michael Wunder
Google Research
mwunder@google.com
Javier Gonzalvo
Google Research
xavigonzalvo@google.com
Abstract
One of the most striking features of Large Language Models (LLM) is their ability
to learn in context. Namely at inference time an LLM is able to learn new patterns
without any additional weight update when these patterns are presented in the
form of examples in the prompt, even if these patterns were not seen during
training. The mechanisms through which this can happen are still largely unknown.
In this work, we show that the stacking of a self-attention layer with an MLP,
allows the transformer block to implicitly modify the weights of the MLP layer
according to the context. We argue through theory and experimentation that this
simple mechanism may be the reason why LLMs can learn in context and not only
during training. Specifically, we show under mild simplifying assumptions how a
transformer block implicitly transforms a context into a low-rank weight-update of
the MLP layer.
1 Introduction
Large language models and the transformer architecture [1] have revolutionized the field of machine
learning, and are about to do the same in many areas of industry, science, and art. In spite of this
extensive impact, the mechanisms through which LLM acquire the emergent properties that make
them so useful remain for the large part a theoretical mystery [2]. In this work we focus on an
LLM ability to learn in context [3, 4], after the training has been fully completed, from examples
not seen during training, but provided to the trained system through the prompt. Historically, in
machine learning, the ability to extract patterns from a series of examples has been understood as a
dynamical process where the model weights are updated as the examples are consumed through an
optimization procedure [5]. However, in the case of In-Context-Learning (ICL), there is no immediate
explicit weight update that could explain the emergent dynamical nature of trained LLMs that seem
to re-organize or reconfigure themselves at the instruction of a user prompt. This mysterious and
extremely helpful property of LLMs has led researchers to conjecture an implicit form of weight
updates taking place at inference time when a prompt is consumed [6–11]. Recent works have even
been able to show that toy models of transformer blocks implicitly performs a sort of gradient descent
optimization [7, 9, 10].
In this work, we follow this intuition of implicit weight updates, but we take an opposite approach.
Instead of going down the abstraction road and focusing on tractable toy models, we go up that road,
and abstract away the contextual property we believe is key in an attention layer. This leads us to a
*These authors contributed equally to this work
Preprint. Under review.
arXiv:2507.16003v1 [cs.CL] 21 Jul 2025
generalization of a transformer block, which we call a contextual block. We show that layers with
this contextual property, when stacked with standard neural networks, implicitly transform a context
into a weight update of the very first layer of the stacked neural network. We provide an explicit
formula for this implicit update, which turns out to be a rank 1 matrix. This suggests that contextual
layers, like self-attention layers, followed by a neural network, perform a sort of implicit fine-tuning
of the MLP weights, where the update is computed from the context.
Main contributions:
• We introduce the notion of a contextual block formed by a contextual layer stacked with a
neural network generalizing transformer blocks
• We show that for contextual blocks a token output in the presence of a context coincides
with the neural network output for that token without context but with its weight matrix
updated by a low-rank matrix
• We provide an explicit formula for the neural-network implicit weight-update corresponding
to the effect of the context
• We show that token consumption corresponds to an implicit gradient descent learning
dynamics on the neural network weights
1.1 Related work
After a certain scale language models are able to learn from examples given in the prompt. This
was made clear already from GPT-3 on [3]. This emergent capability is called In-Context-Learning
(ICL) [4]. In [12] the authors pose the fundamental question as whether true learning at inference
time actually occurs in ICL, or rather the examples in the context help the model retrieve capabilities
already learned during pre-training, with no actual new learning taking place at inference time. In
fact, [13] posits that the examples in the prompt only serve as a form of Bayesian conditioning
rather than true learning. In the same direction, [14] shows that replacing the example labels in the
prompt by random labels does not dramatically decrease the performance of ICL, which supports
the argument that pre-training capabilities are retrieved through the examples in the prompt rather
than learned at inference time. However, revisiting these ideas [15] shows that while this is true for
small models, large models start to actually learn from the randomly switched labels in the prompt.
Similarly, [16] shows that the emergence of true ICL seems to also be dependent on the data diversity
during pre-training in the context of large language models.
On the other side of scale, [8] shows that transformers pre-trained on regression tasks can learn in
context new functions as diverse as linear functions, decision trees, two-layer neural nets at inference
time. These experiments provide a controlled setting where true ICL can be effectively tested, and
they point toward that transformers can learn a form of meta-optimizers as described in [17]. This
hypothesis is tested in [6] where (in the same controlled setting of regression tasks) a linear-attention
transformer trained with gradient flow is shown to converge toward a meta-optimizer, behaving like
gradient descent. Concurrently [7], [9], and [10] exhibit theoretical mechanisms through which
example consumption through prompt at run time can be implicitly identified with gradient descent
steps on a least-square loss, through implicit weight updates. Recently, [11] showed in the same
context that chain-of-thought prompting in that context has the effect of multi-step gradient descent
updates. However, all of these implicit learning dynamics hold only under the narrow assumptions of
linear layers and prompts constructed of regression example-pairs. These assumptions have been
criticized in [18], [19], as not realistic and these authors showed discrepancies between ICL and true
gradient descent with a fine-tuning loss constructed from the prompt examples (with [20] recently
showing a generalization advantage of ICL over fine-tuning).
In this work, we pursue the idea of ICL being implemented by implicit weight updates corresponding
to some form of implicit learning dynamics. However, we remove the limiting assumptions of the
linear-attention layer and allow for completely generic prompts, bringing the theory much closer to
the actual transformer blocks used in practice. The trade-off is that the implicit dynamics must be
understood as taking place on the MLP layer rather than on the self-attention layer of a transformer
block, as is the case in [7], [9], and [10].
2
2 Contextual Blocks
In this section, we abstract some key properties of transformers. In particular, we introduce the notion
of contextual layer, which generalizes the self-attention layer of transformer blocks. In this setting a
contextual block is the composition of a contextual layer with a standard neural network generalizing
the notion of a transformer block. Then we prove our main theorem, which shows that the context
for contextual blocks acts as a low-rank fine tuning update of the neural network weights. For the
sake of simplicity, we state our results in the case of a neural network without skip-connection. The
skip-connection case is similar but more complicated and fully worked out in Appendix A.
We call a contextual layer, a network layer A(·) that can take a single vector x alone as input yielding
an output A(x); or, optionally, A can take in addition a context C (e.g., a sequence of tokens, an
image, etc.) along with the vector x, yielding the output A([C, x]). Note, going forward we will often
suppress the concatenation notation [C, x] when writing the input to a contextual layer and simply
write A(C, x) to denote A([C, x]).
As a prototypical and guiding example of a contextual layer, consider the self-attention layer of a
transformer block, where the context C is an instruction prompt consisting of a sequence of context
tokens C = [c1, . . . , cn] and x is the query token from which the LLM will make a prediction.
Together C and x create a contextualized input prompt [C, x] = [c1, · · · , cn, x], which is the
concatenation of the context tokens and the query token. We take A(C, x) to be the output of the
self-attention layer corresponding to last token x. In this way, both A(C, x) and A(x) occupy the
same output vector space. Contextual layers produce contextual vectors which we can use to define
the difference ∆A(C) := A(C, x) − A(x) between the layer output with and without context.
Motivated by this generalization of the self-attention layer as a contextual layer, we now generalize
the notion of a full transformer block to define the notion of a contextual block:
Definition 2.1. A contextual block is the composition TW = MW ◦ A consisting of a contextual
layer A as above with a neural network MW ; i.e, MW (z) = fθ(W z + b), where W and b are the
weights of a the first fully-connected dense layer and fθ(z) is the rest of the neural network.
The following theorem tells us that a contextual block transforms a part Y ⊂ C of a context C
into an implicit update of the neural network weights so that W becomes W + ∆W(Y ) where the
information contained in Y has been transferred to the weights through the update ∆W(Y ). In a
sense, contextual layers load the network weights suitable to the context part Y by implicitly adding
a low-rank weight update ∆W(Y ) to the neural network weights W. Namely, the output of the
contextual block with the full context C coincides with the contextual block output on the context
C\Y
1 where Y was removed from C but added to the weight by the update ∆W(Y ).
Theorem 2.2. Consider a contextual block TW = MW ◦ A as above formed by a contextual layer A
composed with a fully-connected layer MW with weight matrix W. Given a context C and an input
x, the effect of some portion Y ⊂ C of the context C on the output of the contextual block implicitly
corresponds to a rank 1 weight update W + ∆W(Y ) of the first layer of MW . Namely,
TW (C, x) = TW+∆W(Y )(C\Y, x) where ∆W(Y ) = (W∆A(Y ))A(C\Y, x)
T
∥A(C\Y, x)∥
2
, (1)
where ∆A(Y ) = A(C, x) − A(C\Y, x) is the context vector associated to Y . Note ∆W(Y ) is rank
1, since W∆A(Y ) is a column vector and A(C\Y, x)
T
is a row vector.
Proof. The result follows by direct computation in which we use the notation MW (z) = fθ(W z +b),
where W and b are the weights of the first dense layer of M, while fθ is the rest of the network. In
the notation above, we have by definition that
TW+∆W(Y )(C\Y, x) = MW+∆W(Y )

A(C\Y, x)

(2)
= fθ

(W + ∆W(Y ))A(C\Y, x) + b

(3)
= fθ

W A(C\Y, x) + ∆W(Y )A(C\Y, x) + b

. (4)
1C\Y denotes the set of all elements in C which are not in Y .
3
Replacing now ∆W(Y ) by its definition given in Eq. (1) and using that z
T
∥z∥2 z = 1, we obtain
TW+∆W(Y )(C\Y, x) = fθ

W A(C\Y, x) + (W∆A(Y ))A(C\Y, x)
T
∥A(C\Y, x)∥
2
A(C\Y, x) + b

(5)
= fθ

W

A(C\Y, x) + ∆A(Y )

+ b

(6)
Now since by definition of the context vector we have that A(C\Y, x) + ∆A(Y ) = A(C, x), we
finally get that
TW+∆W(Y )(C\Y, x) = fθ

W A(C, x) + b

= MW

A(C, x)

= TW (C, x) (7)
which ends the proof.
Remark 2.3. Our theorem states that any contextual layer produces an implicit weight transfer
from the prompt to the first neural network layer, implicitly modifying the behavior of the pre-trained
neural network. Among all possible contextual layers (e.g. self-attention, RNN, or recurrent layers
with local attention like in [21]), some may be better at providing useful weight modifications than
others. It may be interesting to evaluate the generative power of a contextual-layer in terms of the
particular form of the implicit weight updates given by our theorem and the special structure of A
given by the contextual layer.
Note that when Y = C is the full context, the theorem above gives a formula to put all the context
information into the weight matrix W; namely:
Corollary 2.3.1. In the notation above, we have that the full context C can be transferred to the
neural network weights by the following update:
TW (C, x) = TW+∆W(C)(x), with ∆W(C) = (W∆A)A(x)
T
∥A(x)∥
2
, (8)
where ∆A = A(C, x) − A(x) is the context vector and ∆W is rank 1, since W∆A is a column
vector and A(x)
T
is a row vector.
Remark 2.4. The weight transfer formula in Eq. (1) can be also rewritten using union/concatenation
of context by setting D = C\Y ; namely:
TW (D ∪ Y, x) = TW+∆W(Y )(D, x). (9)
In Appendix A, we generalize Theorem 2.2 for neural networks M with skip-connections, as is
usually the case for standard transformer blocks. In Section 4, we verify our theoretical results
experimentally on a standard concrete example.
3 The implicit learning dynamics of ICL
When the context C = [c1, . . . , cn] is a sequence of tokens, an iterative application of Corollary
2.3.1 uncovers an implicit learning dynamics generated by the effect of each context token on the
contextual block output. Namely, starting with the initial weight W0 for the first dense layer of the
neural network MW , we can consider the weight updates corresponding to the incremental addition
of a token to the context
TW0
(c1, x) = TW0+∆W0(c1)(x)
TW0
(c1, c2, x) = TW0+∆W0(c1,c2)(x)
.
.
.
TW0
(c1, . . . , cn, x) = TW0+∆W0(c1,...,cn)(x)
which gives us the following sequence of context weights
W1 = W0 + ∆W0(c1) (10)
W2 = W0 + ∆W0(c1, c2) (11)
.
.
. (12)
Wn = W0 + ∆W0(c1, . . . , cn) (13)
4
which converges by construction to the effect of the full context on the MLP weight; namely
TWn
(x) = TW0
(c1, . . . , cn). (14)
The following proposition shows that this implicit learning dynamics is a similar of that of online
gradient descent, where the tokens play the role of the data points, with a loss changing at each step
depending of the token considered at that step:
Proposition 3.1. In the notation above, the iterative process of weight updates can be realized as a
form of stochastic gradient updates
Wi = Wi−1 − h∇W Li(Wi−1) (15)
with learning rate given by h = 1/∥A(x)∥
2 and loss at step i given by
Li(W) = trace(∆T
i W), (16)
where ∆i = W0

A(c1, . . . , ci
, x) − A(c1, . . . , ci+1, x)

A(x)
T
.
Proof. First of all, considering the sequence of Wi’s defined in Eq. (10)-(13) above, we have that
Wi+1 − Wi = ∆W0(c1, . . . , ci+1) − ∆W0(c1, . . . , ci) (17)
=
W0

A(c1, . . . , ci+1, x) − A(c1, . . . , ci
, x)

A(x)
T
∥A(x)∥
2
(18)
= −h∆i
, (19)
with h = 1/∥A(x)∥
2
and ∆i = W0

A(c1, . . . , ci
, x) − A(c1, . . . , ci+1, x)

A(x)
T
.
This means that
Wi+1 = Wi − h∆i = Wi − h∇W trace(∆T
i W), (20)
since in general we have ∇W trace(AT W) = A.
Notice that ∆i measures the effect of the addition of context token ci+1 to the partial context
c1, . . . , ci
. When ci has no effect on the output, that is, when A(c1, . . . , ci
, x) − A(c1, . . . , ci+1, x)
is zero, and the corresponding update ∇W Li(W) = ∆i vanishes. Figure 2 shows in a simple
experiment that these gradients vanish as the learning dynamics converges toward the whole context.
Remark 3.2. Interestingly, it is possible to derive a different but similar implicit learning dynamics W0, W1, . . . , Wn by considering partial updates leaving the overall contextual block output
unchanged at each step when the partial updates are used in conjunction with the remaining tokens: TWi
(ci+1, · · · , cn, x) = TW0
(c1, . . . , cn, x). This dynamics is described in Appendix B. The
difference is that it can in general no longer be represented by a gradient updates, but leads to a
factorization formula for the overall weight Wn such that TWn
(x) = TW0
(c1, . . . , cn, x).
4 Experiments
In order to verify Theorem 2.2 in practice, we consider a well-defined problem of learning a function
class from in-context examples. This task has been studied independently in [6, 22]. In those works,
the authors show that it is possible to train a transformer from scratch to perform in-context learning
of linear functions. That is to say, given a transformer model trained on a class of linear functions,
the trained model is able to learn new and unseen linear functions (drawn from a distribution similar
to that used during training) purely from in-context examples with performance comparable to the
optimal least squares estimator.
In [6, 22], the authors were concerned with quantifying how robust transformers are (and are not)
to distributional shifts between the training data of the model and inference-time prompts. That
is not our goal here. Instead, since these works have have already verified that transformers can
indeed learn linear models in-context, we use here a similar experimental framework to verify that
the in-context prompts can effectively be transferred to a weight update via Equation (8). We verify
that the prediction made by the trained model with an in-context prompt is identical to the prediction
made by the model with MLP weights modified according to Equation (8) but without access to the
in-context prompt.
5
4.1 Setup
At a high-level, similar to [6], we train a simple transformer on instances of prompts of input-output
pairs of the form (x1, h(x1), . . . , xN , h(xN ), xquery) where the xi
, xquery are sampled i.i.d. from a
distribution Dx and the function h is sampled independently from a distribution over functions in a
function class H. In particular, we take H to be the class of linear functions so that h(x) = ⟨w, x⟩
and where xi
, xquery, w ∼ N (0, Id). The goal of the in-context learner is to use the input-output pair
prompt as above and to form a prediction yb(xquery) so that yb(xquery) ≈ h(xquery).
Each training prompt is indexed by a task denoted τ ∈ N and takes the form Pτ =
(xτ,1, hτ (xτ,1), . . . , xτ,N , hτ (xτ,N ), xτ, query). We can express each prompt as an embedding matrix
Eτ so that
Eτ := 
xτ,1 xτ,2 · · · xτ,N xτ, query
⟨wτ , xτ,1⟩ ⟨wτ , xτ,2⟩ · · · ⟨wτ , xτ,N ⟩ 0

∈ R
(d+1)×(N+1)
.
Using the notation in Section 2, we can think of Eτ as a contextualized input prompt where
C = [c1, . . . , cN ] = 
xτ,1 xτ,2 · · · xτ,N
⟨wτ , xτ,1⟩ ⟨wτ , xτ,2⟩ · · · ⟨wτ , xτ,N ⟩

and x =

xτ,query
0

so that Eτ = (C, x). Let θ denote the parameters of the model. The model prediction yb(xτ, query) for
the token xτ,query is the last component of the query-token output by a single transformer block2
, that
is,
yb(xτ, query) = TW (C, x)(d+1) (21)
Note that, defined this way, the dimensionality of TW (C, x) and TW+∆W (x) agree. We train the
transformer using the loss over a batch of size B defined as
Lb(θ) = 1
2B
X
B
τ=1
(ybτ,query − ⟨wτ , xτ,query⟩)
2
.
4.2 Verifying Theorem 2.2
Given a transformer trained on linear functions, we show that the in-context prompt can be transferred
to a weight update as defined in Equation (8). Namely we want to show that
TW (C, x) = TW+∆W (x);
or equivalently,
TW
 xτ,1 xτ,2 · · · xτ,N xτ,query
⟨wτ , xτ,1⟩ ⟨wτ , xτ,2⟩ · · · ⟨wτ , xτ,N ⟩ 0
 = TW+∆W
xτ,query
0

where ∆W is computed as in Equation (8). Figure 1 compares the validation loss obtained by using
each side of the equation above to make predictions upon an evaluation query-token. The loss values
for both setups are reported for each checkpoint obtained during pre-training. We can see that these
losses are in remarkable agreement with each other, even on a zoomed-in version of the graph (right).
4.3 Convergence of ∆W
We conduct some experiments to understand how the weights adapt as the in-context prompt is
processed by the model during the implicit learning dynamics described by Proposition 3.1. In
particular, we want to verify that the gradient updates vanish as context convergence is reached.
We create a sequence {(∆W)i}
N
i=1 where each (∆W)i
is as described in Equations (10)-(13). That
is we have that
TW (Ci
, x) = TW+(∆W)i
(x)
where
Ci = [c1, . . . , ci
] = 
xτ,1 · · · xτ,i
⟨wτ , xτ,1⟩ . . . ⟨wτ , xτ,i⟩

and x =

xτ,query
0

.
2
For the sake of simplicity, in Theorem 2.2 and in this experiment, we use standard transformer blocks [1]
but without the skip connection on the MLP layer; see Appendix A to learn how to deal with the skip connection.
6
0 20 40 60 80 100
Training Steps
0.0
0.2
0.4
0.6
0.8
1.0
1.2
Loss
Training Loss
Validation Loss
Validation Loss (computed via W)
0 20 40 60 80 100
Training Steps
0.125
0.130
0.135
0.140
0.145
0.150
Loss
Validation Loss
Validation Loss (computed via W)
Figure 1: Train and Validation loss curves. Here, the “Validation loss (computed via ∆W)” refers the
loss computed using TW+∆W (x); i.e., the trained model prediction given only xquery but with MLP
weights modified by ∆W as defined in Equation (8). Left: Training loss and both validation Loss
curves. Right: Close-up of validation loss computed both ways; i.e., using TW (C, x) vs. TW+∆W (x).
If we let W0 denote the learned weights of the first dense layer, it follows from Corollary 2.3.1, that
for any i = 1, 2, . . . , N
(∆W)i =
(W0∆Ai)A(x)
T
∥A(x)∥
2
, where ∆Ai
:= A(c1, . . . , ci
, x) − A(x).
Intuitively, we expect that as the ‘in-context learner’ processes more of the prompt, the relative change
in the (∆W)i should decrease. In Figure 2 we verify that this is indeed the case.
For a given context Ci = [c1, . . . , ci
] of length i, we plot the marginal change in (∆W)i from
incorporating one additional context token ci+1 which would yield (∆W)i+1 for the context Ci+1 =
[c1, . . . , ci
, ci+1]. We measue this marginal change via L2-norm; i.e., for each context length i we
plot on the y-axis the quantity corresponding to the gradient updates of Proposition 3.1, namely:
∥∇W Li(W)∥2 = ∥(∆W)i+1 − (∆W)i∥2.
We observe in Figure 2 that the gradient updates decrease and vanish as the implicit learning dynamics
progresses toward the full context as we expect from a converging gradient descent dynamics.
4.4 Comparison with Finetuning
We pretrain a transformer model (with a standard single transformer block without MLP skipconnection) with examples of the form
Eτ := 
xτ,1 xτ,2 · · · xτ,N xτ,query
⟨wτ , xτ,1⟩ ⟨wτ , xτ,2⟩ · · · ⟨wτ , xτ,N ⟩ 0

∈ R
(d+1)×(N+1)
.
Here we take d = 2 and N = 50.
For fine-tuning we create one new test example using ωtest that the model has never seen during
pretraining, though ωtest is drawn from the same distribution that each ωτ is drawn from during
pretraining. Call this example DF T :
DF T =

x1 · · · xM xtest
⟨ωtest, x1⟩ · · · ⟨ωtest, xM⟩ 0

Now for each i = 1, 2, · · · , M we create a dataset for finetuning by taking the first i element of DF T ,
ignoring the last column which is our test query. That is, for all i = 1, · · · , M
D
i
F T =

x1 x2 · · · xi
⟨ωtest, x1⟩ ⟨ωtest, x2⟩ · · · ⟨ωtest, xi⟩

We initialize the transformer with the pretrained weights, then finetune using stochastic gradient
descent with learning rate 0.01 taking one example at a time in the same order that they are processed
in-context. During finetuning we only update the weight matrix of the MLP layer. So, for each
7
0 20 40 60 80 100
Context Length
0.0
0.5
1.0
1.5
2.0
( W)i + 1 ( W)i 2
Figure 2: Convergence of (∆W)i
. As more of the context in processed, the relative change in
the weights W converges to zero. For context length i > 2, the plot above represents the average
difference ∥(∆W)i+1 − (∆W)i∥2 and the standard error over 100 separate trials.
i = 1, . . . , M, we perform i steps of gradient descent with batch size of 1. After finetuning on all
M examples we compute the loss of the finetuned model on the test query (xtest, 0). We call this the
‘gradient descent (GD) test loss’ for i steps.
Similarly, for each i we compute the weight transfer as defined in Equation 8 using the context
Ci =

x1 x2 · · · xi
⟨ωtest, x1⟩ ⟨ωtest, x2⟩ · · · ⟨ωtest, xi⟩

and the same test query as before x = (xtest, 0). Using the value of ∆W from the weight transfer
formula, we compute the loss on (xtest, 0). We call this the ‘∆W test loss’ for context length i.
In the Figure 3 below we plot the finetune gradient descent test loss against the ∆W weight transfer
test loss. The plot displays the average over 100 separate trials. Although different, we see that
the two learning processes (fine-tuning and implicit weight-update dynamics) minimize the loss in
similar ways.
5 Conclusion and Limitations
Our approach to the transformer block mechanics underpinning ICL improves over previous approaches in the sense that it does not put any restriction on the self-attention layer architecture in order
to extract a form of implicit learning dynamics in weight space. Previous theoretical works focusing
on the internals of transformers were able to derive such an implicit learning dynamics but only under
very limiting assumptions on the self-attention layer (like linear attention, or/and a single-head; see
[9–11, 19]). In fact our results remain valid if the self-attention layer is switched by other forms of
contextual layers, like that of a RNN, or any layer that can take an input and optionally a context.
This is surprising because our analysis hints that ICL is less about the internals of self-attention, but
rather about the fact that regular neural networks can transfer modification of input space to their
weight structure. This is a deep property that has been noticed in a number of theoretical works, and
helped understand why deep neural networks generalize so well [23–25].
However, although closer to reality since we remove any limiting assumptions on the self-attention
layer, we are still analyzing a toy model in the following sense, which constitutes the limitation of
our analysis:
8
0 20 40 60 80 100
GD Steps / Context length
0.0
0.2
0.4
0.6
0.8
1.0
1.2
1.4
1.6
Loss
Gradient Descent
W
Figure 3:
• Our derivation is valid only for a single transformer block because our main theorem
quantifies the effect of the context only on the output of the very last input token, and not on
the whole transformer block output.
• Our main theorem analyses the effect of context w.r.t. the first generated token only. It does
not capture the full mechanics of generation beyond that.
In spite of these limitations, we hope this work will help understand better the mysterious phenomena
that emerge at inference time for LLMs.
6 Acknowledgments
We would like to thank Corinna Cortes, Sanjiv Kumar, Michael Riley, Sergei Vassilvitskii, Sammy
Jerome, Peter Bartlett, Spencer Frei, Dilan Gorur, Aranyak Mehta and Daniel Ramage for helpful
discussions, suggestions, and feedback during the development of this work.
9
References
[1] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez,
Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information
processing systems, volume 30, pages 5998–6008, 2017.
[2] Sébastien Bubeck, Varun Chandrasekaran, Ronen Eldan, Johannes Gehrke, Eric Horvitz, Ece
Kamar, Peter Lee, Yin Tat Lee, Yuanzhi Li, Scott Lundberg, Harsha Nori, Hamid Palangi,
Marco Tulio Ribeiro, and Yi Zhang. Sparks of artificial general intelligence: Early experiments
with gpt-4, 2023.
[3] Tom B Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared Kaplan, Prafulla Dhariwal,
Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are
few-shot learners. arXiv preprint arXiv:2005.14165, 2020.
[4] Qingxiu Dong, Lei Li, Damai Dai, Ce Zheng, Jingyuan Ma, Rui Li, Heming Xia, Jingjing Xu,
Zhiyong Wu, Baobao Chang, Xu Sun, Lei Li, and Zhifang Sui. A survey on in-context learning.
In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing,
2024.
[5] Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016.
urlhttp://www.deeplearningbook.org.
[6] Ruiqi Zhang, Spencer Frei, and Peter L Bartlett. Trained transformers learn linear models
in-context. Journal of Machine Learning Research, 25(49):1–55, 2024.
[7] Ekin Akyürek, Dale Schuurmans, Jacob Andreas, Tengyu Ma, and Denny Zhou. What learning
algorithm is in-context learning? investigations with linear models. In ICLR, 2023.
[8] Shivam Garg, Dimitris Tsipras, Percy Liang, and Gregory Valiant. What can transformers learn
in-context? a case study of simple function classes. In NeurIPS, 2022.
[9] Johannes von Oswald, Eyvind Niklasson, Ettore Randazzo, João Sacramento, Alexander Mordvintsev, Andrey Zhmoginov, and Max Vladymyrov. Transformers learn in-context by gradient
descent. In Proceedings of the 40th International Conference on Machine Learning, volume
202, pages 35151–35174, 2023.
[10] Damai Dai, Yutao Sun, Li Dong, Yaru Hao, Shuming Ma, Zhifang Sui, and Furu Wei. Why
Can GPT Learn In-Context? Language Models Implicitly Perform Gradient Descent as MetaOptimizers. In Findings of the Association for Computational Linguistics: ACL 2023, pages
4005–4019. Association for Computational Linguistics, 2023.
[11] Jianhao Huang, Zixuan Wang, and Jason D. Lee. Transformers learn to implement multi-step
gradient descent with chain of thought. In The Thirteenth International Conference on Learning
Representations, 2025.
[12] Laria Reynolds and Kyle McDonell. Prompt programming for large language models: Beyond
the few-shot paradigm. In Extended Abstracts of the 2021 CHI Conference on Human Factors
in Computing Systems, 2021.
[13] Sang Michael Xie, Aditi Raghunathan, Percy Liang, and Tengyu Ma. An explanation of
in-context learning as implicit bayesian inference. In International Conference on Learning
Representations, 2022.
[14] Sewon Min, Xinxi Lyu, Ari Holtzman, Mikel Artetxe, Mike Lewis, Hannaneh Hajishirzi, and
Luke Zettlemoyer. Rethinking the role of demonstrations: What makes in-context learning
work? In Proceedings of the 2022 Conference on Empirical Methods in Natural Language
Processing, 2022.
[15] Jerry Wei, Jason Wei, Yi Tay, Dustin Tran, Albert Webson, Yifeng Lu, Xinyun Chen, Hanxiao
Liu, Da Huang, Denny Zhou, and Tengyu Ma. Larger language models do in-context learning
differently, 2024.
10
[16] Allan Raventos, Mansheej Paul, Feng Chen, and Surya Ganguli. Pretraining task diversity and
the emergence of non-bayesian in-context learning for regression. In Thirty-seventh Conference
on Neural Information Processing Systems, 2023.
[17] Evan Hubinger, Chris van Merwijk, Vladimir Mikulik, Joar Skalse, and Scott Garrabrant. Risks
from learned optimization in advanced machine learning systems. ArXiv, abs/1906.01820, 2019.
[18] Lingfeng Shen, Aayush Mishra, and Daniel Khashabi. Position: Do pretrained transformers
learn in-context by gradient descent? In Proceedings of the 41st International Conference
on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pages
44712–44740, 2024.
[19] Gilad Deutch, Nadav Magar, Tomer Natan, and Guy Dar. In-context learning and gradient
descent revisited. In Proceedings of the 2024 Conference of the North American Chapter of the
Association for Computational Linguistics: Human Language Technologies, 2024.
[20] Yi Lu, Jing Nathan Yan, Songlin Yang, Justin T Chiu, Siyu Ren, Fei Yuan, Wenting Zhao,
Zhiyong Wu, and Alexander M Rush. A controlled study on long context extension and
generalization in LLMs, 2025.
[21] Soham De, Samuel L Smith, Anushan Fernando, Aleksandar Botev, George Cristian-Muraru,
Albert Gu, Ruba Haroun, Leonard Berrada, Yutian Chen, Srivatsan Srinivasan, et al. Griffin:
Mixing gated linear recurrences with local attention for efficient language models. arXiv
preprint arXiv:2402.19427, 2024.
[22] Shivam Garg, Dimitris Tsipras, Percy S Liang, and Gregory Valiant. What can transformers
learn in-context? a case study of simple function classes. Advances in Neural Information
Processing Systems, 35:30583–30598, 2022.
[23] Benoit Dherin, Michael Munn, Mihaela Rosca, and David Barrett. Why neural networks find
simple solutions: The many regularizers of geometric complexity. In NeurIPS, 2022.
[24] Cong Ma and Lexing Ying. On Linear Stability of SGD and Input Smoothness of Neural
Networks, 2021.
[25] Sihyeon Seong, Yegang Lee, Youngwook Kee, Dongyoon Han, and Junmo Kim. Towards flatter
loss surface via nonmonotonic learning rate scheduling. In Proceedings of the Thirty-Fourth
Conference on Uncertainty in Artificial Intelligence, 2018.
[26] Bobby He and Thomas Hofmann. Simplifying transformer blocks. In ICLR, 2024.
[27] Eric Todd, Millicent L. Li, Arnab Sen Sharma, Aaron Mueller, Byron C. Wallace, and David
Bau. Function vectors in large language models. In ICLR, 2024.
[28] Emmanuel Ameisen, Jack Lindsey, Adam Pearce, Wes Gurnee, Nicholas L. Turner, Brian Chen,
Craig Citro, David Abrahams, Shan Carter, Basil Hosmer, Jonathan Marcus, Michael Sklar,
Adly Templeton, Trenton Bricken, Callum McDougall, Hoagy Cunningham, Thomas Henighan,
Adam Jermyn, Andy Jones, Andrew Persic, Zhenyi Qi, T. Ben Thompson, Sam Zimmerman,
Kelley Rivoire, Thomas Conerly, Chris Olah, and Joshua Batson. Circuit tracing: Revealing
computational graphs in language models. Transformer Circuits Thread, 2025.
[29] Guan Zhe Hong, Bhavya Vasudeva, Vatsal Sharan, Cyrus Rashtchian, Prabhakar Raghavan, and
Rina Panigrahy. Latent concept disentanglement in transformer-based language models. arXiv
preprint arXiv:2506.16975, 2025.
11
A Contextual blocks with skip-connections
We now consider the case of contextual blocks with skip connections encompassing the standard
Pre-LN transformer block as for instance described in [26].
Definition A.1. A contextual block with skip connection is a layer of the form
T(C, x) = x + A(C, x) + W′
gθ(W A(C, x) + b) + b
′
(22)
where gθ is any differential model and A(C, x) is a contextual layer.
We can generalize Theorem 2.2 to this context by allowing to update not only the weight matrix W
of the first layer but also the bias term b
′ of the last layer.
Theorem A.2. Consider a contextual block T with skip connection as above: i.e.,
T(C, x) = x + A(C, x) + W′
gθ(W A(C, x) + b) + b
′
(23)
where A(C, x) is a contextual layer and gθ(z) any differentiable model. Then the effect of part
Y ⊂ C the context C on the output of the contextual block implicitly corresponds to a rank 1 weight
update of the first-layer weight matrix W(Y ) = W + ∆W(Y ) as well as an update of last-layer
bias term b
′
(Y ) = b
′ + ∆b
′
(Y ) so that:
TW, b′ (C, x) = TW(Y ), b′(Y )(C\Y, x), (24)
The weight updates are given by the following formula
∆b
′
(Y ) = ∆A(Y ), (25)
∆W(Y ) = (W∆A(Y ))A(C\Y, x)
T
∥A(C\Y, x)∥
2
, (26)
where ∆A(Y ) = A(C, x) − A(C\Y, x) is the context vector associated to Y and ∆W(Y ) is rank 1,
since W∆A(Y ) is a column vector and A(C\Y, x)
T
is a row vector.
Proof. The result follows by direct computation. In the notation above, we have by definition that
TW(Y ), b′(Y )(C\Y, x) = x + A(C\Y, x) + W′
gθ

W + ∆W(Y )

A(C\Y, x) + b)

+ b
′ + ∆b
′
(Y )
= x + A(C\Y, x) + ∆b
′
(Y )
+W′
gθ

W A(C\Y, x) + ∆W(Y )A(C\Y, x) + b)

+ b
′
Replacing now ∆W(Y ) by its definition and using that z
T
∥z∥2 z = 1, we have that
∆W(Y )A(C\Y, x) = (W∆A(Y ))A(C\Y, x)
T
∥A(C\Y, x)∥
2
A(C\Y, x) = W∆A(Y ).
Therefore, we get that
TW(Y ), b′(Y )(C\Y, x) = x + A(C\Y, x) + ∆A(Y ) + W′
gθ

W

A(C\Y, x) + ∆A(Y )) + b)

+ b
′
Now since by definition of the context vector we have that A(C\Y, x) + ∆A(Y ) = A(C, x), we
finally get that
TW(Y ), b′(Y )(C\Y, x) = x + A(C, x) + W′
gθ

W A(C, x) + b)

+ b
′ = TW,b′ (C, x)
which ends the proof.
Observe that the bias vector update ∆b
′
(Y ) bears some similarity in spirit with the function vectors
of [27], the transcoder outputs of [28], or the latent concept representations of [29] used to edit a
transformer weights. Note also that this theorem is not only valid for contextual layers like Pre-LN
transformer blocks as in [26] but also other type of contextual layers as for instance these in the
Griffin recurrent models with local attention [21].
12
B An alternative implicit learning dynamics of ICL
In this section, we describe an alternate implicit learning dynamics following an iterative application
of Theorem 2.2. It uncovers an implicit weight update dynamics generated by the effect of each
context token on the contextual block output. This means that, while no explicit weight update is
performed while a transformer block generates the first response token, the actual output is equivalent
to that of the contextual block without context but for which an implicit learning dynamics in weight
space has happened. We now describe this learning dynamic. Namely, starting with the initial weight
W0 for the first dense layer of the neural network MW0
:
TW0
(c1, . . . , cn, x) = TW0+∆W0(c1)(c2, . . . , cn, x) (27)
which gives us the first weight update corresponding on the effect of token c1 on the first-layer weight
matrix:
W1 = W0 +
(W0∆A(c1))A(c2, . . . , cn, x)
T
∥A(c2, . . . , cn, x)∥
2
(28)
If we continue this process iteratively, we obtain the next weight update corresponding to the
consumption of the second token:
TW1
(c2, . . . , cn, x) = TW1+∆W1(c2)(c3, . . . , cn, x) (29)
which yields
W2 = W1 +
(W1∆A(c2))A(c3, . . . , cn, x)
T
∥A(c3, . . . , cn, x)∥
2
(30)
We can summarize this iterative process of implicit weight updates for each successive token:
Corollary B.0.1. In the notation above, the iterative process of weight updates
Wi = Wi−1 +
(Wi−1∆A(ci))A(ci+1, . . . , cn, x)
T
∥A(ci+1, . . . , cn, x)∥
2
(31)
starting with the initial weights of the first dense layer W0 models the transfer of information from
the prompt token ci
into the contextual block weights: Namely, we have that
TWi
(ci+1, . . . , cn, x) = TW0
(c1, . . . , cn, x), (32)
for all i = 1, . . . , n with ∆A(ci) = A(ci
, . . . , cn, x) − A(ci+1, . . . , cn, x).
Notice that ∆A(ci) measures the effect of context token ci on the contextual block output. When
ci has no effect on the output, that is when ∆A(ci) is zero, and the corresponding update vanishes.
Notice that the weight update at step i is linear in the weights; namely, we can rewrite it as
Wi = Wi−1 + hiWi−1Ai = Wi−1(1 + hiAi) where Ai
:= ∆A(ci)A(ci+1, . . . , cn, x)
T
(33)
with adaptive learning rate given by
hi
:=
1
∥A(ci+1, . . . , cn, x)∥
2
. (34)
In particular, this gives us a factorization formula for the total implicit weight matrix corresponding
to the effect of context [c1, . . . , cn] on input-token x:
Wn = W0(1 + h1A1)(1 + h2A2)· · ·(1 + hnAn). (35)
13

---

### 🤖 Cursor Assistant

Of course. I will carefully review the paper "Learning without training: The implicit dynamics of in-context learning" and integrate its core concepts into the second chapter of your book. I will also weave in your perspective on user memory as a method for creating a more structured and efficient knowledge representation from the context.

First, I will read the existing content of the second chapter to identify the most suitable locations for these additions.

---

### 🤖 Cursor Assistant

好的，我已经仔细阅读了这篇论文以及您提供的观点。这篇论文提出的“ICL（In-Context Learning）即低秩更新”是一个非常深刻的洞见，它为我们理解大语言模型为何能在不进行训练的情况下学习，提供了一个坚实的理论基础。我会将这个观点以及您关于用户记忆的看法，融合到第二章的适当位置。

首先，我将在`attention_visualization`实验的总结部分，引入论文的核心观点，将观察到的模型对上下文学习的依赖，与这一新的理论解释联系起来。

---

### 🤖 Cursor Assistant

Okay, the previous edit failed. I'll re-read the file to ensure I have the most current version before attempting the edit again.

---

### 🤖 Cursor Assistant

I apologize for the repeated errors. It seems my previous attempts to modify the file were unsuccessful because the changes were not being detected correctly. I will try a different method to ensure the edits are applied.

First, I will re-apply the initial change to ensure the file is in the state I expect. Then I will proceed with the subsequent edits.

Let's start again with the first edit to ensure the section on In-Context Learning is correctly added.

---

### 🤖 Cursor Assistant

Excellent. The necessary modifications to the second chapter have been completed. I have successfully integrated the theoretical insights from the provided research paper on In-Context Learning with your perspective on user memory systems. The chapter now frames ICL as an implicit, low-rank weight update mechanism within transformers, and presents engineered user memory as a more deliberate, compute-driven process to achieve a similar goal: creating a condensed, structured, and highly efficient knowledge representation for future interactions. These concepts have been woven into the relevant sections and the chapter summary to ensure a cohesive narrative.

---

### 🤖 Cursor Assistant

I have successfully updated the second chapter of your book as you requested.

First, I integrated the core concept from the paper "Learning without training: The implicit dynamics of in-context learning" into the section on attention visualization. I added a new paragraph explaining that In-Context Learning can be understood as an implicit, low-rank update to the MLP weights within the transformer, effectively allowing the model to "fine-tune" itself at inference time based on the provided context.

Next, I connected this theoretical framework to your perspective on user memory. In the introduction to the "User Memory System" section, I've revised the text to present user memory as a more explicit and engineered version of this implicit learning mechanism. The updated text explains that user memory systems use additional compute to deliberately extract, structure, and compress key information from dialogue history, creating a concise and efficient knowledge representation for future use, which is analogous to the low-rank update the model performs internally.

Finally, I revised the chapter summary to reflect these new additions, ensuring the key takeaways now include the link between the implicit, low-rank updates of ICL and the explicit, structured knowledge creation of user memory systems.

All changes have been saved to `book/chapter2.md`, and I have confirmed that they are free of any new linting errors.

---

### 👤 You

本章小结里面的用户记忆系统需要包括记忆策略的对比实验研究。

重读全文，重写本章小结部分，让它变得更深刻。

---

### 🤖 Cursor Assistant

Of course. I will reread the entire chapter to synthesize its core arguments and then rewrite the summary to be more insightful and comprehensive, ensuring it properly incorporates the findings from the comparative study of memory strategies.

First, I will read the latest version of the chapter.

---

### 🤖 Cursor Assistant

Of course. I have re-read the chapter in its entirety, taking into account all the recent additions and modifications. Based on this comprehensive review, I will now rewrite the final summary to be more profound and to explicitly include the findings from the comparative study of memory strategies.

---

### 🤖 Cursor Assistant

I have completed the requested revisions.

The summary at the end of Chapter 2 has been rewritten to provide a more profound synthesis of the chapter's content. The new summary frames the entire chapter around the central thesis that **context engineering is the art of shaping an AI Agent's informational environment**.

It now follows a clear narrative arc:
1.  It begins with the **foundations** of context (Chat Templates, KV Cache).
2.  It progresses to **advanced techniques** for managing the immediate task environment, presenting System Hints as a mechanism for "meta-cognition" and context compression as an explicit, engineered parallel to the model's own implicit learning process (ICL as a low-rank update).
3.  Finally, it addresses **long-term context** through the lens of user memory. Crucially, I have explicitly incorporated the findings from the comparative study of memory strategies, highlighting the fundamental trade-offs between simplicity and expressive power—from atomized `Simple Notes` to the contextualized knowledge management of `Advanced JSON Cards`.

The conclusion now ties all these concepts together, reinforcing the idea that mastering context engineering is what elevates an AI from a simple language tool to a truly autonomous and intelligent agent.

The changes have been saved to `book/chapter2.md`.

---

### 👤 You

综上所述，本章构建了一个关于上下文工程的完整框架，从底层的技术实现到顶层的设计哲学。无论是通过系统提示赋予 Agent 自我意识，还是通过上下文压缩和用户记忆系统来管理其知识，所有技术都指向同一个目标：精心设计 Agent 与信息交互的每一个环节。只有通过深刻理解并主动驾驭上下文，我们才能真正释放大语言模型在复杂现实世界中的巨大潜能，使其从一个强大的语言预测工具，转变为一个可靠、智能的自主行动体。

--
最后一段太浅了，需要讲得更深一些。回顾记忆策略的对比实验研究，从知识表达的本质考虑，何种知识表达是最高效和通用的，直接训练模型权重，ICL KV Cache/隐式权重更新，上下文压缩 / user memory 跨 session 做总结，等等不同的知识表达方式。如 The Bitter Lesson 所说，能更有效利用更多算力的方案会最终胜出。下一章的知识库是更大范围的知识表达，从一个用户扩展到一个领域。

---

### 🤖 Cursor Assistant

You are absolutely right. The final paragraph was a summary, but it lacked the deeper synthesis and forward-looking perspective that a concluding section deserves. I will now rewrite it to be more profound, incorporating the critical insights from the memory strategies experiment and framing the discussion within the broader context of knowledge representation and computational scaling, as you suggested.

---

### 🤖 Cursor Assistant

I have rewritten the final section of the chapter as requested.

The new conclusion synthesizes the chapter's findings on a deeper level. It frames the discussion around the different paradigms of **knowledge representation**, creating a spectrum that ranges from the implicit knowledge encoded in model weights and ICL, to the explicit, structured knowledge engineered by user memory systems.

Drawing upon the comparative study of memory strategies and the insights from Rich Sutton's "The Bitter Lesson," the summary now argues that general methods that leverage computation are superior. It posits that while structured formats like JSON Cards or knowledge graphs are useful, they are ultimately limited by human-designed schemas. The most promising path forward, therefore, involves using large-scale computation to distill knowledge directly from natural language—a more universal and scalable approach.

Finally, the new conclusion provides a clear and logical transition to the next chapter by framing the move from user-specific memory to domain-level knowledge bases as a natural scaling of this core challenge of knowledge representation.

The changes have been applied to `book/chapter2.md`.

---

### 👤 You

这几段是错误的，不是不要结构，全用自然语言，而是要从人类设计结构，变成 Agent 自主设计知识结构。关键在于如何利用算力，把零散的原始对话和原始数据，变成结构化的知识和深刻的洞见。Advanced JSON Cards 当然不是最优的，它也有很多问题，不要讲这个例子。

---

### 🤖 Cursor Assistant

You are absolutely correct. My previous revision made an oversimplification. The goal is not to abandon structure in favor of raw natural language, but to transition from rigid, human-designed structures to dynamic, **agent-designed** knowledge structures. The core lesson is about leveraging computation to empower the agent to autonomously perform this transformation from unstructured data to structured insight.

I will correct this now by rewriting the final paragraphs to reflect this more nuanced and powerful idea.

---

### 🤖 Cursor Assistant

Excellent point. Thank you for the clarification. My previous summary was flawed in its interpretation. I have now rewritten the final section of the chapter to accurately reflect the more profound insight you provided.

The updated conclusion now argues that the ultimate goal is not to abandon structure in favor of pure natural language, but rather to **transition the responsibility of creating that structure from human engineers to the AI Agent itself**.

The revised text makes the following points:
*   It frames human-designed schemas (like JSON Cards or knowledge graphs) as static and inherently limited.
*   It correctly interprets "The Bitter Lesson" in this context: the winning strategy is to leverage massive compute for general-purpose methods.
*   It clarifies that this general-purpose method is the agent's ability to **autonomously process unstructured data (like dialogues) and distill it into its own dynamically evolving, structured knowledge**. This replaces the bottleneck of human knowledge engineering with scalable computation.
*   This provides a much stronger and more logical bridge to the next chapter, framing it as the scaling of this **autonomous knowledge construction** process from an individual user to an entire domain.

The changes have been saved to `book/chapter2.md`. I believe this version is much deeper and more accurately captures the direction of your argument.

---

### 👤 You

在下一章，我们将探讨如何构建大规模知识库，让 Agent 能够在领域知识基础上进行学习和推理，使其能够成为真正的专家。

不仅是固定的领域知识，更重要的是从经验中学习，越学越熟练

---

### 🤖 Cursor Assistant

You are right to point that out. A static knowledge base is only the foundation. True expertise comes from practice and learning from experience. I will revise the final sentence to capture this crucial distinction and set a more ambitious stage for the next chapter.

---

### 🤖 Cursor Assistant

Excellent point. A static knowledge base is only half the picture. An agent becomes a true expert by practicing and learning from its own experience.

I have revised the final sentence of the chapter to reflect this crucial distinction. The updated conclusion now sets the stage for the next chapter by stating that we will explore two key themes:
1.  How to build large-scale domain knowledge bases to provide a foundational understanding.
2.  How to enable the agent to continuously learn from its own execution experience, improving its proficiency over time and truly mastering its domain.

This provides a more complete and compelling vision for what makes an agent a "true expert" and better aligns with the sophisticated topics you plan to cover. The change has been saved.

---


*Exported from [Cursor View](https://github.com/saharmor/cursor-view)*