Many people, upon seeing the digital identity wallet, will first react with the thought that "identity can finally be taken with you." However, what I care about more now is not whether it can be taken out, but whether it can truly be caught by the subsequent processes after it is taken out. In simple terms, I no longer consider digital identity as an entrance to "show who you are"; instead, I see it as a stress test: when identity, attributes, qualifications, and credentials truly become portable, will the on-chain system acknowledge that these things have existed, or will it reset as if nothing has happened with a change of entrance, activity, or permission judgment.
This is what I believe makes digital identity the most easily overestimated. Many people think that as long as you can prove who you are, things will naturally go smoothly afterward. But in reality, what is truly valuable has never been 'proving who you are', but rather 'after proving, can the system refrain from starting from scratch to ask you again'. You have a wallet, you have attributes, you have credentials, you have even completed some form of qualification verification, yet once you enter specific processes like activity collection, permission activation, distribution judgment, and access review, many systems still act as if they haven't seen anything. It’s not that identity cannot be expressed, nor that attributes cannot be carried, but rather that the subsequent processes do not treat these objects as usable inputs. Thus, you will see a particularly absurd situation: attributes are carryable, but undertaking is not transferable; proof exists, yet subsequent execution still repeatedly requests it.
This is also why I now see SIGN as more of an 'attribute undertaking layer' rather than simply an 'identity item' or 'proof item'. In my view, what is truly worth focusing on in the Sign Protocol is not whether it can issue an attestation, but whether the schema can first clarify the attribute structure, and whether the attestation can pin down 'this subject holds this qualification, this status, this declaration' as an object that can still be recognized later. More critically, can the TokenTable or subsequent permissions, distribution, and access processes directly use these objects for judgment? If it can only prove 'has been', but cannot continue to 'be used', then it essentially remains at the display layer, not the execution layer. You can see an identity object, but the system does not eliminate any repeating judgments because of its existence; in this case, the identity is merely digitized, not processed.
I increasingly feel that this matter will become more and more important in the future. Because whether it is a digital identity wallet or more broadly, on-chain identity, institutional attributes, compliance qualifications, cross-platform authentication, what is truly valuable will not be 'I have a lot of credentials', but rather 'can these credentials really reduce the friction of re-entering the process'. In the future, identity will not be the rarest, but the capability to undertake will be. Because there can be an increasing number of identity tools, more wallet entry points, and even more standardized attribute expressions, but if the processes afterward do not recognize them, these things will ultimately become a pile of exquisite entries rather than executable middleware. For users, this means that you have already proven once, yet still have to start over in the next stage; for projects, this means that you have already established a judgment once, yet there is no way to reuse it for distribution, permissions, collection, and verification of these real actions.
So from the perspective of an observer or even a trader, I am now less moved by superficial numbers like 'how many identity wallets are connected' or 'how many credentials have been issued'. What I want to see more is whether these attributes have really entered the downstream execution layer. If not, then it resembles identity visualization, or rather, the enrichment of identity materials; if so, then it is closer to system upgrades. Because the hallmark of system upgrades has never been an additional layer of display, but rather a reduction in repeated verifications, a reduction in repeated uploads, a reduction in 'prove it again'. For me, this capability may not be the hottest in the short term, but once it is realized, its stickiness will be strong, as it addresses the friction of the process itself.
So now I'm looking at $SIGN not just to see if it can establish identity and proof. What I want to see more is whether it can fill in the capability behind 'proving who you are'. Existing attributes and credentials, do they naturally enter subsequent activities, permissions, and distribution logic; schema and attestation, do they start to undertake 'attribute migration', rather than just staying at issuance; external discussions, will they gradually shift from 'can it prove who you are' to 'after proving, is it still recognized later on'? Because the real difficulty of digital identity is not proof itself, but whether the subsequent processes still treat you as someone who has been proved after the proof is completed.