北京的街头，早高峰的地铁上，满脸刷着大红线的鸭舌帽推上来，那是像素原生的时代。

那时候，“像素”就是硬通货，盯着屏幕看几秒，只要眼够毒，就能挑出设计师的审美。

那时候认定，UI 设计就是画像素点，把线、色、圆角拼凑起来，像搭乐高一样好办粗暴。 那时候不懂为啥要做圆角，只认定圆角好看；那时候不懂为啥间距要留那么细，只认定空格少显得紧凑。

那时候当作只要字够大，按钮够亮，用户就爱了。

那时候还认定交互就是代码写得越多，页面动得越花哨，用户越中意。

那时候还在跟产品经理吵架，认定产品经理不懂审美，设计师能懂啥，产品经理只要让加载快点就行。

那时候认定，只要代码写得漂亮点，页面加载快，产品就成功了。

那时候连“像素”两个字都不敢大声说，怕显得自己像个老古董。 那时候还在用 Photoshop 当设计神器，总认定 PS 里的功能多到没边，按钮、图层、蒙版、滤镜……全是工具。

那时候当作只要文件保存格式是 PSD，那格式就一辈子是你的了。

那时候还在追求“高清”，认定只要输出分辨率够高，不管啥屏幕，都能看。

那时候连“响应式”都叫不上名字，只知道把网页做成个大平板，要么强行全屏。

那时候认定用户就是傻瓜，只要界面不崩，弹窗不闪，一切 OK。

那时候连“微交互”都叫不上，只知道鼠标点进去有个点击动画，那个叫特效。

那时候还在用浏览器 F12 打开开发者工具，认定那玩意儿能显示所有渲染信息，那是懂行的。

那时候认定浏览器就是设计器的工具栏，没它不中。

那时候还在幻想，只要用户看到个漂亮的界面，用户自然就会用。

那时候还在为一点点加载慢，为一点点延迟，为用户的耐心，如此死命地磨。

那时候连“动效”都叫不上名，只知道页面加载完有个转场动画。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“触控”都叫不上名，只知道手指头点上去有个点击特效。

那时候认定触控就是触控，不需求寻思。

那时候还在用 Mockup 当原型，认定那玩意儿能画效果，那效果就对了。

那时候认定 Mockup 就是画图工具，不需求管。

那时候还在为一点点的加载延迟，为一点点的响应慢，为用户的耐心，如此死命地耗。

那时候连“动效”都叫不上名，只知道页面加载完有个转场。

那时候认定动效是富余的，用户充其量就是看个静态图。

那时候还在用 Figma 当设计工具，认定那玩意儿能正常画，那画就对了。

那时候认定 Figma 就是 Photoshop 的替代品，画完直接送人。

那时候还在用抖音当灵感来源，认定抖音上啥素材好看，那就拿来用。

那时候认定素材素材就是素材，只要素材够多，创意无限。

那时候还在用 GitHub 当代码仓库，认定那玩意儿能托管代码，那代码就稳了。

那时候认定代码托管就是托管，不需求管。

那时候还在为一点点的 Bug 崩溃，为一点点的 UI 瑕疵，为用户的耐心，如此硬气地怼。

那时候连“