AI 时代下的软件工程:质量、品味与未来工程师的转型 AI Engineer 2026-04-21

AI 趋势与软件质量的权衡

Gergely Orosz: 好的。所以,我们没有看到,但请举手示意如果你使用 Linear,如果你听说过 Linear,以及如果你想使用 Linear。

Original English

Gergely Orosz: Awesome.

So, we didn't see it, but hands up if

you do use linear and hands up if you

heard of linear and hands up if you want

to use linear.

Tuomas Artman: 太棒了,很高兴看到。我们可能会谈论 Linear,但我们要谈论一些更大的事情,这是一个有点新的趋势,Thomas,我们正在谈论事情正朝着错误的方向发展,对吧?什么正朝着错误的方向发展?

Original English

Tuomas Artman: Awesome. Great to see. So we're we could

be talking about linear but we're gonna

talk about something a bit bigger which

is a bit of a new trend that with Thomas

we're talking about things are trending

the wrong way right now. What is

trending the wrong way?

Tuomas Artman: 当代理人 um 能够立即为你做一切事情时,会发生什么?事实可能是,就像钟摆已经摆得太远,朝着错误的方向,即如果你收到一个功能请求,你可能现在就处于立即交付它的位置,而这可能就是错的。我估计,希望从现在起半年或一年后,我们会明白,在没有真正思考的情况下就交付东西是 um,是一件坏事。 um,将会发生的是,um,你因为拥有这种巨大的力量,可以有效地只是,就像,交付每一个进来的请求,或者你脑海中闪过的每一个想法,你将有效地交付 um,一个不那么出色的软件。 um,史蒂夫·乔布斯Steve Jobs)曾经说过,你知道,伟大的产品来自于对 999 件事说“不”,而对一件事说“是”。而有了 AI um,我们可能处于一个很容易就说“是”并尝试各种事情然后交付它的地方,并最终到达一个非常复杂的地方,在那里软件实际上对最终客户来说 um,不再那么好用了,或者用户体验变得令人困惑。

Original English

Tuomas Artman: The

so

what happens when when agents um are

capable of doing everything um

immediately for you? uh the the fact

that might be that like the pendulum has

swung too far into the into the wrong

direction where if you get a feature

request you might now be in the position

to just immediately ship it and that

might be the wrong thing to do. Um and I

I reckon that you know hopefully half a

year from now or a year from now we'll

understand that like shipping things uh

without really too much thinking is um

is a bad thing. Um what will happen is

is that um you because you have this

this enormous power of effectively just

like shipping every single request that

comes in or every single thing thing

that pops into your head uh you will

effectively ship you know a software

that that is not great. Um Steve

Jobs back in the day said that you know great

products come out of saying no um to you

know 999 things and yes to one thing and

with AI um we might be in a place where

um it's just too easy to say yes and and

try things out and ship it and get to a

very convoluted place where you know

software actually doesn't work for the

end customer um nicely anymore or that

the user experience get gets confusing.

Tuomas Artman: 我们过去曾有一个 um,一个阻碍我们这样做的东西,那就是实际的工程曾经是困难的。所以我们曾经会去思考这些功能以及我们想要构建的应用程序,然后才开始工程,因为工程曾是如此耗时。

Original English

Tuomas Artman: We used to previously have um this you

know uh this thing that gated us from

from doing this which was like the

actual engineering used to be hard. So

we used to think about these these

features and these these you know um the

the applications that we wanted to build

before we actually started engineering

because engineering was such a time you

know waste of time and it it took a long

time to ship something. So um yeah that

Gergely Orosz: 但我想挑战你一下。在 AI 出现之前,我们难道没见过这种情况发生吗?一些公司就已经在发布大量功能并堆砌,你现在看到什么不同了吗?我们实际上看到越来越多的公司,你知道,做更多这种,我不知道,像功能拆分的事情吗?

Original English

Gergely Orosz: >> but I want to challenge you a little bit

on that. Did we not see this happen

before before AI that some companies

were already just like shipping putting

on a bunch of features and stacking and

what are you seeing different right now?

Are you actually are we actually seeing

more companies you know do more of this

like I don't know like feature factoring

thing

Tuomas Artman: 我们曾在 Uber 有过一段共同的经历,我们一起工作过,你知道,我们经历过超高速增长 um,而 Uber 的事情是,这是一个“赢家通吃”的市场,你知道,当年 Uber 在美国和其他地方都在竞争,你必须不惜一切代价去大量交付 um,去超越竞争对手 um。而我在 Uber 看到的,就像是那样的超高速增长,我再也不想经历一次了,就像,不惜一切代价,你知道,只是在救火,维持基础设施运行,尽可能快地扩展,尝试一切,你知道,试图成为赢家 um。而我现在看到 AI 的类比,因为当每个人都拥有交付,你知道,大量功能的能力时,你总是在与别人竞争,你的竞争对手可能是一个小团队,甚至是一个非常能干的个人,他们能够利用 AI 来交付和 um,你知道,构建一个拥有与你相同功能集的产品。 um,而在那种世界里,我认为变得重要的是,你知道,以一种方式脱颖而出,即你构建有品味的软件,构建高质量的软件,从而,你知道,保持某种竞争优势。所以,在 Linear,即使在 AI 出现之前,你就在构建有品味的软件,专注于这些事情,但然后这些工具出现了,它们变得更强大,特别是自从 Cloud Code 出现以来,现在我们有了 Opus 4.5,你应该能够更快地交付,你的工程团队、你的 CTO、你的工程团队应该能够更快地交付。你告诉他们什么?你告诉他们应该在 Linear 里面做什么?他们应该放慢速度吗?不。对吧?Linear 里面到底发生了什么?告诉我们。

Original English

Tuomas Artman: we had a you know common experience at

Uber where we worked together where we

you know we we went through hyperrowth

um and the thing about Uber was that it

was a winner takes it all market and

Uber was going against back in the day

in the in the US and um you just had to

ship immensely um and and and you know

just outpace you know the competition um

at all costs. Um and what I saw at Uber

like was was that hyperrowth that I

never want to go through again which was

like um at all costs you know just

fighting fires keeping the

infrastructure running scaling as

quickly as possible trying out

everything and and you know trying to

come out you know as a winner um in in

in that front and I I I see the analogy

to to AI nowadays because when everybody

has the capability of shipping you know

tons of functionalities like you you

always are in a competition with with

somebody else like your competition

might be you know a small team or even

one person that you know is very capable

of using AI to to to ship and um you

know build a product that is you know

has the same feature set as as as you

do. Um and in that world like I I think

it becomes important to sort of you know

stand out um in a way where like you

build tasteful software and where you

build high quality software um and thus

sort of you know maintain some sort of

you know competitive advantage um

towards your your uh competition. So at

linear even before AI came out you were

building tasteful software and and and

focusing on those things but then these

tools came out and they became more

powerful specifically since cloud code

came out now we have Opus 4.5

you should be able to ship faster your

engineering team your CTO your

engineering team should be able to ship

a lot faster what are you telling them

like what should they be doing inside of

linear with this capability should they

be slowing down. No. Right. What's going

on inside a line of linear? Tell us.

Tuomas Artman: 嗯,有,也有没有。我们仍然,你知道,我们仍然会考虑 um,我们推出的每一个功能,就像我们不会走仅仅尝试原型的路线。我们希望保持我们的设计角度,并且,你知道,考虑用户体验。仍然对大量的 um 客户请求说“不”。你知道,很多时间并没有花在实际的工程上。 um,它更多的是弄清楚客户想要什么。我们确实收到了大量的,你知道,功能请求。我们通常不会直接交付它们。我们真正想做的是,嗯,从我们的客户那里获得大量反馈,与我们的客户交谈,弄清楚他们实际的问题是什么,然后将它们归类,弄清楚,你知道,这些功能请求的根本原因到底是什么,然后想出一个解决方案,这个解决方案,嗯,对那一组特定的功能请求来说是完美的。 um,这需要时间。AI 可以帮助你,你知道,很多。当然,它可以,你知道,浏览所有这些请求并给你一个总结,也许可以,你知道,指向不同的分组。 um,但这仍然需要时间来弄清楚什么是正确的事情。 um,然后你进入设计,并且,并且,并且弄清楚,你知道,如何围绕你想要构建的功能来实现出色的用户体验?是的,我们想加快速度,我们也在加快速度。 um,产品建设的某些方面,你有,你知道,加速了很多。 um,例如修复 bug。 um,每个功能,嗯,每个产品都有 bug,而且,你知道,bug 的流入基本上是恒定的。 um,现在修复它们要容易得多。我,你知道,我们 10% 的 bug 是通过,你知道,一个单一的 AI 实例自动修复的,就像当一个 bug 进入 Linear 时,嗯,无论是来自,你知道,我们的工程师报告的,还是客户报告的问题,10% 都会自动,你知道,生成一个 PR 并自动合并,而无需工程师做任何事情。 um,随着时间的推移,这将会变得更多。我确实预见到一个未来,就像它会接近 100%。 um,在接下来的几年里。 um,所以这是你可以加速你构建的地方。将这些不需要太多思考或,你知道,设计专业知识或思考功能的任务,将它们交给代理人。你关心质量,你,你一直,让我们来谈谈 Cloud Code。你怎么看 Cloud Code?你觉得它安全吗?

Original English

Tuomas Artman: >> Well, yes and no. Like we still, you

know, we we still think about um every

single feature that we put out like we

we don't we don't go down the route of

of just trying out prototypes. We want

to sort of maintain that design angle

that we have and and you know think

about the user experience. Still say no

to a lot of um customer requests. Like a

lot of time you know hasn't gone into

really just engineering. Um it's it's

about figuring out like what the

customer wants. uh we do get a ton of

you know feature requests. We usually

never ship them as such. Like what we

really want to do um is uh get a lot of

feedback from our customers, talk to our

customers, figure out what their actual

problem is and then sort of group that

together and figure out like you know

what is actually the root cause of of

you know these feature requests and then

come up with a solution that is um that

that is perfect for that you know

particular group of feature requests.

Um, and that takes time. Like AI can

help you, you know, so much. Obviously,

it can sort of, you know, go through all

of those requests and give you a summary

and maybe sort of point you to sort of,

you know, different groupings. Um, but

it still takes time to figure out what

the right thing is. Um, and then you go

into design and and and figure out like,

you know, h how do you implement a great

UX around uh the functioning that you

want to want to build? Yes, we want to

move faster and we are moving faster. Um

there's certain aspects of uh of you

know building a product that has you

know accelerated a lot. Um one is for

example fixing bugs. um every feature uh

every every product has bugs and you

know the inflows of bugs is effectively

constant and um those are much easier to

fix now like I you know 10% of our bugs

are automatically fixed by you know a

singleshot AI instance like when a bug

comes in into linear um be it from sort

of you know our engineers uh reporting

those or a customer reporting a problem

10% are automatically you know up with a

PR and automatically landed without an

engineer doing anything um over time

that will go upline. I do foresee a

future where like it gets closer to

100%. Um in the next few years um so

that's something where you can

accelerate your your building like hand

off you know these tasks that don't

really require much thinking or you know

design expertise or thinking about

functionality hand that off to agents

you care about quality and you you can

tell the linear and and you have always

always had let's talk about cloth

code. What do you think about cloud

code? And

you can you can it's it's it's a safe

space.

Tuomas Artman: 是的,希望它是一个安全空间。 um,Anthropic 说,你知道,Cloud Code 的所有功能都是由 Claude 编码的。 um,我认为这表明,如果你真正使用,你知道,Cloud Code,无论是 CLI 还是桌面应用程序,你都可以发现问题和,你知道,小的,你知道,小的 bug。我,我会说,实际上并没有多少,你知道,只是质量修复,但它们实际上是 bug,嗯,在几秒钟内。 um,它有点,你知道,慢。它可能,你知道,运行的方式让你,你没有真正看到。对我来说,那是一种 um,由于移动速度太快而产生的副作用。就像他们再次,他们在与 OpenAI 竞争,而且 um,他们需要交付功能,他们需要非常快速地移动,因为这可能是一个更好的赢家通吃市场。 um,而副作用是,质量就是,你知道,不存在。

Original English

Tuomas Artman: Yeah, hopefully it's a safe space. Um,

Anthropic said, you know, that all of

the functionality has been has been in

cloud code has been coded by claude. Um,

and I think it it shows like if you if

if you truly use you know cloud code

either the CLI or or then the desktop

application um you can spot problems and

you know small sort of you know

small bugs. I I would say there's

there's not really, you know, just

quality fixes, but they're actually bugs

um in in effectively a few seconds. Um

it is a bit, you know, slow. It might

be, you know, functioning in a way that

you you don't you don't really really

see. And to me, that's sort of a um a

side effect of moving so fast. Like

obviously they they again they're in a

competition with, you know, Open AI and

um they need to ship features and they

need to sort of move move really quickly

uh because it might be a better takes

all market again. Um, and uh, the side

effect of that is that the quality just,

you know, isn't there.

Gergely Orosz: 是的。嗯,这并不是一个很棒的收购宣传,所以我认为你不会成功的。但是,嗯,我绝对喜欢,你可以看到这些东西中的一些,但质量如何衡量?我们之前也谈过,嗯,就在我们开始谈论 Uber 之前,我们如何尝试衡量质量,以及那如何影响你学习关于它的可衡量之处以及不可衡量之处。

Original English

Gergely Orosz: >> Yeah. Well, this was not a great

acquisition pitch, so I I don't think

you're you're going to get there. But,

uh, I absolutely like you you can see

some of these things, but how do you

measure quality?

And we've talked about this before uh

just be just before we started on Uber

how we tried to measure quality and and

how that's influence you to learn what

you can measure about it and what you

cannot.

Tuomas Artman: Uber 是一个很好的例子,说明了衡量质量是多么地困难,因此你就不去衡量。 um Uber 作为一个例子,就像我们有,你知道,这五个主要指标,每个人都在关注和改进。 um,最重要的是收入,就像,它本质上是一个交易性的,你知道,应用程序。 um,你产生的收入越多,就越好。

Original English

Tuomas Artman: Uber is a good example of like where it

is immensely hard to measure quality and

therefore you sort of don't. Um Uber as

an example like we had you know these

five big metrics um that everybody was

looking looking after and looking

looking to improve. Um the big one was

revenue like um it is effectively a

transactional you know application. Um

the more revenue you generate the the

better. So

Gergely Orosz: >> 其他的指标是,比如,完成的行程。

Original English

Gergely Orosz: >> the other ones were like trips taken

Tuomas Artman: >> 行程。

Original English

Tuomas Artman: >> trips taken

Gergely Orosz: >> 行程,行程。

Original English

Gergely Orosz: >> trip trip taken.

Tuomas Artman: >> 嗯。

Original English

Tuomas Artman: >> Uh

Tuomas Artman: >> 我认为行程的质量也是一个指标。

Original English

Tuomas Artman: >> I think the quality of the ride was was

one as well.

Tuomas Artman: >> 从注册到第一次行程的时间。

Original English

Tuomas Artman: >> It also time to first trip from from

sign up to the first time that

Tuomas Artman: >> 就是这样,我们有几个黄金指标。

Original English

Tuomas Artman: >> well that's so we had a few golden metrics

Gergely Orosz: >> 对,但收入那个是大家关注的。所以当你发布一个新功能 um,或者发布了完全新的东西,比如 Uber Pool,举个例子,我不知道哪个先来, Lyft Pool 还是 Uber Pool,我想 Uber 是先开始的,然后 Lyft 才跟上,但是 um,显然如果你发布一个新功能,可以,你知道,降低一次行程的价格,它会增加你的收入,所以你怎么衡量质量呢?你根本就衡量不了。 um,如果,如果没有任何其他平台提供便宜的拼车服务,那么你就不需要质量。 um,而且这就是,你知道,我一直以来的感受。在 ED,就像,我们有工程师,至少在初期,他们关心质量。 um,这是我们的责任,去弄清楚我们发布的某样东西是否出色。我仍然记得我 2012 年加入的时候,我想。 um,我提交了一个 PR,在那时,Uber 应用程序在屏幕中间有一个圆圈,显示行程即将到达的预计到达时间。我改变了地图的边距。 um,然后一个 OG 工程师回复了我的 PR,他是,你知道,从一开始就在团队里。我想他是第一个 iOS 工程师。 um,他说:“哦,这个圆圈差了两个像素。”我当时说:“你测量过吗?”“哦,当然,我测量过了。”然后我说:“我再量一次。”你知道,是的,差了两个像素。所以我不得不把它向上移动一个像素。没有人会真的在意。没有人会注意到,但人们热衷于维护质量。这也是为什么至少在早期,Uber 应用程序性能很好,质量很高。 um,但然后,一旦你有一个足够大的团队,并且你有这些 um 增加收入的激励措施 um,你就会尽快发布新功能,而质量是不会影响你收入的东西,直到它开始影响。所以会发生什么? Uber 发布了 Uber PoolLyft 也跟着发布了 Lyft Pool。所以你有两个竞争产品,价格相同,功能相同。 um,你可以选择其中一个应用程序,随着时间的推移,就像,我的理论,这就是为什么我们想把 Linear 打造成一个高质量的工具,是因为随着时间的推移,人们会选择质量更高的那个。 um,这可能需要一段时间,就像,人们可能仍然使用 Uber,然后每年尝试一下 Lyft,比如一年一次,或者什么的,打开它,然后想,哦,这个用户体验感觉好多了,我感觉我能更快地叫到车,即使价格和他们销售的产品是一样的。所以随着时间的推移,你就会开始失去用户。 um,这将是一个渐进的滑坡。不会有 AB 测试可以让你弄清楚是否应该投资质量。 um,这只会随着时间的推移而发生。这就是它的危险所在。 um,如果你构建了一个质量差的产品,你就给自己打开了被竞争对手超越的门户。 um,嗯,不是被超越,而是被竞争对手慢慢超越。

Original English

Tuomas Artman: >> right but the the revenue one was what

everybody everybody looked after. So

when you shipped a new feature um or

shipped you know something totally new

like you know Uber pool for example um I

don't know which one came first lift

pool or Uber poolool I think Uber

started it and then lift came around but

um obviously if you ship a new feature

that sort of you know makes the price

you know of a of taking a trip lower it

will increase your revenue so how do you

measure quality in that like you you

simply don't um if if there's no other

way of you know if if there's no other

platform that provides you with uh with

with a pool drive that is inexpensive

then uh you you don't really need to

have quality. Um and that was you know

my my feeling throughout like at ED like

we had engineers that that cared at

least in the beginning we had engineers

that cared about quality like it was up

to us to figure out like whether

something we shipped was was great or

not. I I still remember when I joined in

2012, I think. Um I put up a first PR

and back back then the Ubra application

used to have this this poll in the

middle of of the screen that used to

have an ETA of like when when your trip

is, you know, is is is going to arrive.

And I made some changes to the margins

of the of the map. Um and the PR came

back from a from an OG engineer who was,

you know, was on the team for from from

the get-go. I think he was the first iOS

engineer. Um and he he was like, "Oh,

this this pole is off by two pixels." I

was like, "You you measured it?" "Oh,

yeah, sure. I I measured it." And I was

like, "I measured again." And you know,

yes, two pixels off. So, I had to move

it up by one pixel. And that was the

like nobody would would really care.

Nobody would see it, but like people

were keen on upholding the quality. And

that's why at least in the beginning,

the Uber application was was pretty

performant, was was of highest quality.

Um but then like once you have a big

enough team and you've got these um

incentives of just increasing revenue um

you ship new features as as quickly as

possible and and quality is a thing that

like it it doesn't affect your revenue

until it does. So what happens Uber

ships Uber pool lift comes ahead and

ships Uber uh you know Lyft pool as

well. So you've got two competing

products that effectively have the same

price point do the same thing. um you

can choose either one of the

applications and over time like my

theory and and that's why we we you know

want to build linear into this high

quality tool uh is that over time people

will will pick the one that is of higher

quality um it might take a while like

people might be you know sticking to

Uber and then trying out lift you know

once a year or something like opening it

up mean like oh this user experience

actually feels better I I I feel like

I'm getting the car faster um even

though the price and the product that

they sell is is the same. So over time

you will start losing your users. Um and

it will be a gradual you know slip.

There there will be no AB test that you

can do in order to figure out like

whether you should invest in quality. Um

it'll just happen over time. And that's

that's the danger of it. Um if you if

you build a bad quality product, you

open up yourselves uh to uh sort of be

leaprocked by by a competition. Um well

not leaprocked like slowly overtaken by

the competition.

Gergely Orosz: 你在 Linear 做了一些非常独特的事情,我以前从未见过。它叫做“质量星期三”(Quality Wednesdays),我参加过一次你们的“质量星期三”。整个工程团队聚集在一起,这是一个全远程团队。所以每个人都接入,持续了 30 分钟,我记得大约有 25 位工程师在那次通话中,每个人展示一个他们完成的质量修复。从一个像素的改变开始,真的是一个像素的改变,到“哦,我让我们的后端效率大大提高,并且使用了更少的东西”,就这样,砰砰砰砰砰。 um,我想 25 个人花了大约 37 分钟,但不到两分钟。这怎么开始的?是你吗?

Original English

Gergely Orosz: you do something really unique at linear

related to this that I've never seen

before. It's called quality Wednesdays

and I sat into one of your quality

Wednesdays. The whole engineering team

gets together. It's a full remote team.

So everyone just dials in and it was 30

minutes and every engineer I think we

had about 25 engineers on that call

would show one fix that they did was

quality and it went from like a one

pixel change. It was literally a one

pixel to uh oh I just made our our our

back end like way more efficient and and

using less things and it was just boom

boom boom boom boom. Uh and I think it

took like 37 minutes for the 25 people

but it was less than two minutes. How

did this start?

And was this you?

Tuomas Artman: 是我。是的,绝对。 um,主要原因,就像,我想回到,我想大概是三四年前。 um,我们在应用程序中有一个东西,就像,如果你使用它,你可以,你可以,你可以注意到它,就像每一个高亮都需要在你悬停在上面时立即高亮,因为你知道,这让应用程序感觉很快,但是当你移开时,按钮需要有一个非常快速的淡出,因为这会让应用程序感觉很流畅,就像它必须是,你知道,瞬间高亮,然后 150 毫秒后,你知道,淡出,因为这为用户交互增加了一点质量。 um,而且这 desde,你知道,一开始就存在了。 um,然后我有点沮丧,因为我不得不,你知道,向工程师指出这一点,因为如果你不寻找那种非常微小、细致的细节,你就是找不到。就像你实现了一个新功能,然后 um,你只是忘记了 um,你知道,实现它,或者如果你不知道你在寻找什么,你甚至都看不到它。所以,在我的一次户外活动中,因为我厌倦了报告这些,我说,让我给大家展示一下,你知道,他们应该做什么, um,以及他们应该如何实现这些,你知道,小的质量修复。 um,我选择了应用程序的一小部分,我说,你知道,在那里我注意到高亮缺失了,你知道,我把团队召集起来,嗯,我告诉他们,让我们,你知道,花一个小时来弄清楚这个特定视图有什么问题,在我看来,就是信任高亮,大家也都加入进来了。 um,我们发现的是,在视图选项菜单中,我们发现了那个小 UI 的 35 个问题。 um,我当时想,天哪,天哪,天哪。 um,我没看到那些。 um,我完全不知道我们有这么多小问题,就像,当你不是真正关注的时候,你就不会注意到。 um,所以,从那时起,你知道,我所想的,我们想要做的,就是让每个人都始终参与进来,并且,并且,并且尝试在产品中找到问题,因为显然我们充满了,你知道,小的质量问题。如果,你知道,一个小菜单有 35 个东西要修复,那么应用程序的其余部分就有,你知道,数千个。迄今为止,我们可能已经修复了 um 2500 或 3000 个,嗯,这些小的、细致的细节, um,在应用程序中。 um,而且,你知道,这就是它变得更好,并且 um,并且拥有最高的质量标准的原因。 um,你知道,那就是它的开端。但然后我们意识到 um,这有一个很好的副作用。我们告诉大家的是,你必须,每个星期三,你必须自己找到一个问题,就像,我们不会把它们交给你,就像,你必须自己进入产品去找到它。所以人们开始这样做,每周都找到一个问题,一开始很容易,然后变得更难,因为你知道,质量修复减少了,但 um,你知道,人们一直在产品中找到问题。 um,其副作用是,大家,无论何时,当他们构建一个完全不相关的功能时,他们总是在寻找这些小的质量修复,因为他们知道他们必须带着一个修复来参加下一个星期三的会议。

Original English

Tuomas Artman: It was me. Yeah, for

sure. Um the the big one was like I mean

to go back like I think it was three

four years ago. Um we have this thing in

the application like if if you use it um

you can you can you can spot it like

every single highlight needs to

highlight instantaneously when you hover

over it because that you know makes the

application feel fast but when you hover

out there needs to be this very quick

fade out of of a button because that

makes the application feel smooth like

it has to be this like you know

instantaneous highlight and then over

150 milliseconds you know fade out

because that adds a bit of quality um to

to the user interaction and um that was

in place since you know the beginning

like the the the early Um, and then I

got sort of frustrated because I had to

sort of point this out to to engineers

because if you're not looking for that

very small minute detail, you're just

not going to find it. Like you implement

new functionality and um you just forget

to uh you know implement it or you don't

even see it if you're not if you don't

know what you're looking out for. So

what I did as at one of our off sites

because I got frustrated of reporting

these I was like let me show everybody

like you know what what what they should

be doing um and and how they should be

implementing these these you know small

quality quality fixes. Um and what I

took is a very small portion of the

application and I was like you know

where where I noticed that you know the

highlights were missing and and you know

I brought the team together and uh I

told them let's you know spend an hour

trying to figure out what's wrong with

this particular view and in my mind it's

trust the highlights and everybody duck

in um and what we found in it was one of

the view option menus uh we found like

35 problems with with that tiny UI um

and I was holy Holy, holy crap. Um, like

I I didn't see those. Um, I I had no

idea that we had all these small

problems that like you wouldn't notice

when you're when you're not really

looking. Um, so from that, you know,

what what I what I thought we we would,

you know, want to do is like have

everybody always chime in and and and

try to find problems in the product

because apparently we were full of, you

know, small quality quality problems. If

a, you know, small menu has 35 things to

fix, then the rest of the application

has, you know, thousands. And to date,

we've probably fixed um 2,500 or 3,000

um of these small minute details uh in

the application. Um and and that's how,

you know, has become better and um and

and has the highest highest quality bar.

Um that was, you know, that was the

start of it. But then we realized um

there's there's a nice side effect to

this. And what we what we told people is

that you have to every Wednesday you

have to find a problem yourself like we

won't hand them to you like you have to

go in into the product and find it. So

people started doing that every single

week finding a problem and it used to be

um in the beginning it was it was easy

then it became harder because you know

the quality fixes went down but um you

know people kept on finding finding

problems in in the product. Um and the

the side effect of that was that

everybody was all but when whenever they

were building something a totally

unrelated feature there was they were

always on the lookout for these small

quality fixes because they knew they had

to come to the next Wednesday meeting

with a fix

Tuomas Artman: >> 去修复它们。是的。

Original English

Tuomas Artman: >> to get the fix them. Yeah.

Tuomas Artman: >> 是的。所以他们总是在寻找这些,这意味着他们引入的回归越来越少,或者这些,你知道,小的质量回归到产品中。所以,如果你一直在思考质量,并且你意识到了质量相关的事情,那么你一定会犯更少的错误。

Original English

Tuomas Artman: >> Yeah. So they were always looking

looking for those and that meant that

they were introducing less and less

regressions or these you know small

quality quality regressions into the

product anyway. So if you if you think

about quality all the time and if you

are aware um of quality you know things

then uh you're you're bound to make less

mistakes.

Gergely Orosz: 我觉得这个实践我到处都没见过,它既令人惊叹,又相当有雄心。所以,我的意思是,如果你是一个小型初创公司,你应该尝试一下,因为尤其是在现在,有了像这样的代理,这不应该太难做到,而且你可能会得到。

Original English

Gergely Orosz: >> I mean this practice is I haven't seen

it elsewhere and it seems both awesome

also pretty aspirational. So I mean if

you're a small startup like you should

probably try it out if you can because

especially now nowadays with with agents

like like it shouldn't be that difficult

to do and and you might get

Tuomas Artman: >> 如果你是一家大公司,你应该更应该尝试一下。

Original English

Tuomas Artman: >> if you're a big startup you should even

even more try it out.

Tuomas Artman: >> 好了。但有一件事不像那么有雄心,而且容易得多,特别是现在你已经做了,甚至在代理出现之前,就是“零缺陷策略”(zero bug policy)。告诉我这个。这对你来说,“零缺陷策略”意味着什么?在实践中意味着什么?比如,你们肯定有 bug,对吧?我只是扮演魔鬼代言人。

Original English

Tuomas Artman: >> There there we go.

But one thing that is is not as

aspirational and a lot easier to do

especially now that you have been doing

even before agents zero bug policy. Tell

me about this. What does zero bug policy

mean for you and what does it mean in

practice? Like you have bugs surely,

right? I'm just playing devil's advocate

here.

Tuomas Artman: 当然。 um,我们的“零缺陷策略”字面意思就是,如果一个 bug 被报告了,um,它会自动分配给某人,立即,显然使用代理。 um,他们会找到谁创建了这个 bug,或者你知道,谁一直在处理这个区域, um,这就会成为你的最高优先级。你放下其他所有事情。 um,早上醒来,你去你的“我的问题”列表,你看到一个分配给你的 bug。那是你要处理的第一件事,你修复它。或者你也可以选择不修复它。你知道,这很重要。不是每个 bug 都会被修复。如果它,你知道,超级困难或棘手,并且它,你知道,适用于十万分之一的用户, um,你知道,你可能不应该浪费时间。 um,但是每一个 bug 都会立即被修复。 um,这个策略的开始,嗯,来自于这样的想法:bug 是在每个公司以恒定的速率被创建的。当你创建功能,当你创建功能,当你进行工程时, um,你将会创建 bug。而大多数公司,在我们的“零缺陷策略”之前,我们 um,把它们放在一个待办事项列表中。我们说,嗯,你知道,当我们有时间的时候,我们会修复它们。 um,然后随着时间的推移,你的产品会变得越来越糟,在某个时刻你会看到,哦,我的天,我们有 500 个 bug 在待办事项列表里,我们需要做些什么。然后你才开始从顶部修复。而发生的是,嗯,修复 bug 的速率基本上是恒定的。无论你是现在修复,还是两个月后修复,都没有关系。一旦你达到了那个阈值,我们有这么多 bug,你实际上就是在修复所有进来的 bug,只是迟了两个月。所以,牢记这一点,你只需要做一个很小的权衡就能达到零 bug。如果修复 bug 的速率是恒定的,你所需要做的就是停止,你知道,新功能的开发,直到你把 bug 降到零,然后强制执行你将继续,你知道,修复你的 bug,因为立即修复 bug 比三个月后修复它需要更多的精力,如果你关心你问题的总体数量。所以,对我们来说,这意味着,我们花了相当于三周的时间,没有开发任何新功能,只是修复 bug,把它们降到零。 um,从那时起,每个 bug 都会在七天内被修复,通常你知道,在两个小时或三个小时内。 um,这对用户来说意味着,用户在报告 bug 时会非常兴奋,两个小时后他们会收到一封电子邮件,说哦,我们修好了。如果你刷新浏览器, um,我们已经为你解决了。 um,这会让你的用户非常高兴,因为你知道,你很少有这样的体验。

Original English

Tuomas Artman: Sure. Um we zero bug policy literally

means that if a bug gets reported um it

gets assigned to somebody automatically

immediately using agents obviously like

they will find who has created this bug

or who has you know been working in this

area and um that becomes your highest

priority. You drop everything else. Um

the morning you wake up you go to your

my issues list and you see a bug

assigned to you. That's the first thing

you pick up and you fix it. Or you can

also decide not to fix it. Like that's

important. like not every bug gets

fixed. If it's, you know, super hard or

gnarly and it, you know, applies to one

out of, you know, 100,000 users, um, you

know, you probably shouldn't waste your

time on it. Um, but every single bug

gets fixed immediately. And the the the

the start of this um came from from the

idea that like bugs are are are created

at a constant rate at every company.

When you create features, when you when

you create function, when you engineer,

um, you will be creating bugs. And most

of the companies and we prior to our

zero back policy like we um put them in

a backlog. We're like uh you know when

it gets when we get some time like we'll

we'll fix them. And uh what happens over

time is like your product gets worse and

worse and at some point you look like oh

man we've got you know 500 bugs in the

backlog like we need to do something

about it and that's when you start

fixing from the top

and what happens is that um the rate at

which you have to fix bugs is again

constant. It doesn't matter whether you

fix them, you know, two months from now

or immediately. Like once you hit that

threshold of we've got so many bugs,

you're now effectively fixing all the

bugs that come in um except two months

later. So with that small notion in

mind, like there's there's a very small

trade-off that you have to do in order

to get to zero bucks. If the rate that

you have to fix bugs is constant, all

you need to do is stop, you know,

development of new features for as long

as it takes you to, you know, bring your

bugs to zero and then enforce that

you're going to keep on, you know,

fixing your bugs because it's not more

effort to fix bugs immediately than to

fix them three months from now if you

care about the, you know, overall sum of

of of your of your problems. So to us

that meant um we spent effectively three

weeks of of not working on any any new

functionality of just fixing bugs

getting that down to zero. Um and from

there on out every bug gets fixed um

within seven days usually you know in

two hours or 3 hours. Um and what that

means to users like users get super

excited when they report a bug and two

hours later they get an email saying oh

we fixed it if you refresh your browser

um we've got it covered for you. um that

makes you like that makes your users

super happy because you know you don't

really have that experience too often

with with companies.

Gergely Orosz: 好的,一个刁钻的问题。如果我在 Linear 工作,有一个“质量星期三”要来了,然后我被分配了一个 bug,那算吗?

Original English

Gergely Orosz: >> Okay, curve ball question. If I'm

working at linear and there's a quality

Wednesday coming up and I get assigned a

bug, does that count?

Tuomas Artman: 不,那不算。那是缺陷。 um,你必须找到一个质量修复。

Original English

Tuomas Artman: >> No, that does not count. That's that's a

defect. Um you have to find a quality

fix.

Tuomas Artman: >> 哦,天哪。

Original English

Tuomas Artman: >> Oh man,

Tuomas Artman: >> bugs are separate. They they are

immediately immediately created. And now

with you know AIS being capable of at

least pointing you where that problem is

and helping you immensely uh fix bugs I

think like literally every company um

should have a zero bug policy. It it

doesn't make sense to not have one. One

thing that you know when we talk about a

and think about AI agents we think about

speed code generation. We rarely use

quality and AI agents in the same

sentence. Why is that with the tools

getting better? Should AI engines not be

better to have feedback loops? you know

they can write unit tests like should

they not be able to produce better code

better features better UIs even uh no

they they don't feel they they have no

taste um they they simply don't um they

are not human beings I think the last

bastion that you know we have to tackle

at some point and maybe we'll get there

maybe we won't is um you know have you

know tasteful AI being able to create UI

that is you know purpose-built for you

know that specific feature you're

building for the product that you're

building is, you know, has great design

um and has the ability to figure out

like what what a user feels when they

use your application. To give you an

example, um AI doesn't have a concept of

time and currently how it sort of

interacts with your browser is um

effectively timeless. um they take

screenshots or they look at the DOM and

if you ask it to create a very you know

high performant application like yeah it

can go back you know and look at all the

all the things that have been written

about like you know go to versol to host

your next app or you know use caching or

or whatever but it won't be able to use

your application and get frustrated

because you know a click took two

seconds um it knows that one second is

better than two seconds but it it

doesn't know whether two seconds is is

is slow enough. Um the other aspect that

goes into it is um it it doesn't really

see um and it doesn't know what for

example a good use animation is. Um

Emil, one of our um uh design engineers

um just yesterday posted um on on on X

um where he you know did this trial of

you know having agents build certain

animations for you know um certain

functionality like you know bringing up

a pop-up or highlighting a button or

moving things around and um he agents

were totally capable of doing all of

this and then he took a manual step and

was like well if I now take it and just

improve it and make it feel good um

here's the outcome and he has it up on

his side can sort of you try out what

the agent did and what he then he then

fixed and at least to me and I hope

everybody else um like his animations

just feel natural they they feel they

feel like like the welldesigned whereby

the the agent did all the right things

but you know had an ease in as an

animation or or you know did it a bit

too slowly or too quickly um and it just

felt you know unnatural.

Linear 的企业文化与招聘

Tuomas Artman: 我想稍微谈谈 Linear 的文化。第一,在那里工作是什么样的?你如何创造一个真正关心质量、良好的客户体验的团队?你们在那里具体做什么? um,工程师在入职第一天就会接触到什么?是的,我们专门为此招聘,并且我们有一个特定的招聘流程,确保我们能找到那些像我们一样思考,或者愿意构建高质量软件的人。 um,我们的大部分工程师都是产品工程师。我们当然有技术挑战。我们有 um,你知道,一个同步引擎。我们有,你知道,规模。我们需要扩展我们的基础设施。但我们想做的是让大部分工程师专注于产品,构建功能,你知道,以及为客户构建功能,并与客户进行非常高层次的互动。 um,所以首先,我们为此招聘。 um,我们有一个“伯克试炼”(Burke trial),我们对每一位员工都这样做,你知道,好几天,对吧?

Original English

Tuomas Artman: I wanted to talk a little bit about the

culture at Alineir. One, it's like

working there like how you created this

team that really cares about quality

good customer experience. What are what

what are things that you do specifically

there? C can we talk about it on on what

engineers are exposed to who who join

the company from day one? Yeah, we we

hire for for that specifically and we

have a you know specific hiring process

where we make sure that we get people

that think like mind or think think like

us and want to build high quality

software that is beautiful. Um most of

our engineers are product engineers.

They're they're like we obviously do

have technical challenges. We have um

you know a synchronization engine. We

have you know scale. We need to scale

our infrastructure. But what we wanted

to do is have most of our engineers just

be you know focusing on the product and

build features you know and and

functionality for customers and engage

with the customers at a very high level.

Um so first of all we we we hire for

that. Um we have a Burke trial that we

do with every single employee that that

you know several days right

Gergely Orosz: >> 这是一个完整的一周。

Original English

Gergely Orosz: >> it's a full week.

Tuomas Artman: >> 这是一个完整的一周。所以我们,我们显然为此付费,但我们与一个人合作整整一周。他们通常会实现一个全新的项目或产品或功能。 um,有时他们甚至在那周之后就交付了,这真的很神奇。 um,但我们想从中获得的是,只是看看他们如何从头到尾地推动一个产品,弄清楚需要什么。

Original English

Tuomas Artman: >> It's a full week.

So we we obviously pay for that effort

but we work with a with a person for a

full week. they usually implement a

green field, you know, pro project or

product or feature. Um, sometimes they

even ship it after that week, which is

which is pretty amazing. Um, but what we

want to get out of that experience is

just to see them drive, you know, a

product from from start to finish,

figure out what is needed.

Gergely Orosz: >> 所以,这里的反驳是,“等等,一周,你付费,当然,但有人必须花时间离开工作。”一大群优秀的人会说,“不,我要么不能,要么不愿这样做。”

Original English

Gergely Orosz: >> So, a push back here would be like, hang

on, a whole week, you pay for it, sure,

but someone had to take time off of it.

A bunch of great people will say, no, I

I either cannot or will not do that.

Tuomas Artman: >> 好吧,那完全没关系。那些人从一开始就不想在这里。所以,这是自我筛选,但在你经历了如此严格的招聘流程之后,这比我认为的任何其他流程都要长。你的意思是,在大多数地方,你有一个一天的流程,或者它们是堆叠起来的。

Original English

Tuomas Artman: >> Well, that's totally fine. like those

people didn't want to be here in the

first place. So,

it's it's it's self, but after you go

through this pretty rigorous hiring

process, it's a lot longer than I think

any other process. I mean, you know, you

have a dayong process at most places or

or they're stacked across.

Gergely Orosz: 你有没有看到与你在 Uber 招聘时不同的结果?当你招聘 Uber 的时候,你做了常规的事情,比如五次面试,六次面试等等。你看到了什么不同的结果?

Original English

Gergely Orosz: >> Did you see any different result than

for example when you hired at Uber? When

you were hiring at Uber, you you did the

usual, you know, like five interviews,

six interviews and so on. What was the

outcome difference that you're seeing?

Tuomas Artman: 当然,嗯,我们,我们很少出错。 um,我们雇用的大部分人,当然总有几个人,我们 um,我们就是错过了什么,然后 um,我们继续,回到循环中,就像,我们有一些迹象表明我们有点不确定,然后我们还是雇用了那个人。但这些人只是,就像,少数几个。我认为我们的大部分工程师都非常优秀。 um,而且我们的工程标准非常高,并且在不断提高。

Original English

Tuomas Artman: Certainly um like we we've had very few

misses. Um most of the people that we've

hired and sure there always are a few

where we um we just missed something and

um we and going back into sort of the

loops like we there's inklings of like

us being a bit uncertain and then we

went ahead and hired the person anyways.

But those are just like a a few handful

of handful of people like I think most

of our engineers are you know really

excellent. Um and our engineering, you

know, bar is is super high and

constantly increasing.

Gergely Orosz: 然后一旦这些工程师进来,你告诉我一些关于 Slack 频道和客户的有趣的事情,对吧?

Original English

Gergely Orosz: >> And then once those engineers enter, you

told me something interesting about the

Slack channels and customers, right?

Tuomas Artman: 我们确实有 um,与我们所有大客户的 Slack 频道。任何人都可以加入。 um,大多数人都会这样做,就像你浏览客户请求,你浏览人们遇到的问题。 um,我们还记录了我们与客户举行的每一次会议。我们有很多会议,不仅仅是在 CX 方面或 um 支持方面,但我们的 PM 不断地与重要客户交谈,以弄清楚我们下一步应该构建什么,所有这些都被记录下来, um,并且任何有趣的观点都会被标记,所以任何人都可以进入,然后你知道,查看,甚至搜索,嗯,关于特定功能,然后弄清楚,你知道,客户在说什么,他们想要什么。所以每个人都能接触到客户需求,嗯,而这对于伟大的产品来说是超级重要的。这几乎就像,如果你进入 Linear,你就会得到,就像,客户反馈的“高压水枪”,你真的无法逃避看到和感受,你知道,客户的痛苦或喜悦或任何东西。

Original English

Tuomas Artman: We do have um Slack channels with all of

our big customers. It's open to anybody.

Anybody can jump in. Um and most people

do like you browse through customer

requests, you browse through what you

know, what problems people have. And um

we we also record every single meeting

that we have with customers. And we have

a lot of meetings like not only on the

on the CX side or um support but our PMs

have constantly you know talked with

Bler customers to figure out what we

should be building next and all of those

are recorded um and any interesting

points are tagged so anybody can can go

in and then you know look at and even

search uh for you know certain

functionality and figure out like what

are customers saying what what do they

want so everybody gets exposed um to

customer needs uh and that is super

critical if you if you want great

product. It's almost like if you enter

linear, you get this like fire hose of

like what are customers feedback and you

you cannot really escape seeing and

feeling, you know, feeling the customer

pain or joy or whatever that is.

Gergely Orosz: 当然。是的。因为我们是为客户而建的。就像 Linear 最初是一个我们为自己构建的产品。对,我们作为工程师是主要客户。我们已经超越了这一点,就像我们为更大的公司和企业构建。我们已经不是一家大公司了。所以我们必须构建那些,你知道,我们自己不会使用的东西。而做到这一点的方法就是,你知道,与你的客户交谈,弄清楚他们需要什么。

Original English

Gergely Orosz: >> Certainly. Yeah. Cuz we build it for

customers like Liner started off as a

product where we build it for ourselves,

right? We as engineers were the primary

customer. We've grown out of that like

we we build it for larger corporations

and enterprises and we're no big

enterprise. So we have to build things

that you know we wouldn't use ourselves

and the only way to do that is to you

know talk with your customers and figure

out what they need.

未来工程师的角色与建议

Gergely Orosz: 如果你必须展望未来一年,你,你有时会有强烈的意见。所以,让我们把它们带出来,展望一年。你认为软件工程师或产品工程师的角色将如何改变,因为我们拥有这些强大的工具?它们在某些领域变得更好,而在其他领域可能没有那么好。

Original English

Gergely Orosz: >> If you had to look a year ahead you you

you sometimes have strong opinions. So

like let's bring those out a year ahead.

How do you think the role of the

software engineer or product engineer

will change because we do have these

powerful tools. They're getting better

in certain areas and maybe not so much

better in others.

Tuomas Artman: 我认为每个人将在某种意义上都成为产品工程师。如果你考虑一下 AI 的进展,回到四年前,它还不能写一行代码,现在它正在掌管代码库。 um,再往前推四年,如果你仍然相信指数增长仍然存在,我们没有遇到障碍 um,我不知道我们是否会,但 um,如果它继续这样增长,你将不再需要那些将数据从一个地方传输到另一个地方的工程师。你仍然需要那些知道客户想要什么,以及什么是好的功能,或者什么是好的用户体验的工程师。 um,所以我想,你知道,工程师将不得不转向成为以产品为导向和专注于产品的。他们将不得不成为“迷你 PM”,与客户交谈,参与那个层面,嗯,然后可以,你知道,实现客户想要的功能。

Original English

Tuomas Artman: I think everybody will become a product

engineer um in in some sense.

If you if you think about how AI has

progressed um go back like four years it

wasn't able to write a single line of

code and now it's commandeering code

bases um go four years ahead and if you

if you still believe that it's that the

exponential growth is still there and we

don't hit a wall um which I I don't know

if we will but um if it if it keeps on

going growing like this like you you

won't be needing engineers that sort of

pipe data from one place to another you

still will be needing engineers who know

what a customer wants and what a good

feature looks like or what a good user

experience looks like. Um so I think you

know engineers will have to move to

become product oriented and product

focused. They will have to be sort of

mini PMs who sort of talk with customers

are engaging in that layer um and then

can you know implement functionality um

that your customers want.

Gergely Orosz: 哦,天哪。所以,你知道,我记得在 2000 年代,我们作为程序员,你只需要掌握一种语言,然后是多种语言,然后是 QA 工作,你得到了 QA 工作,然后是 DevOps,现在你却说我们要承担产品工作和客户支持工作。

Original English

Gergely Orosz: >> Oh man. So like you know I remember in

like the the 2000 the two 2000s we as a

as a programmer you could just use one

language then it was like multiple

languages then the QA job you got the QA

job then you got DevOps now you're

saying we're the the product job and the

customer support job as well.

Tuomas Artman: >> 哦,其他的都下降了,现在你只需要做,你知道,PM 的工作。

Original English

Tuomas Artman: >> Oh everything else has dropped now like

you just need to do the you know PM job.

Gergely Orosz: 好的。 um,作为最后的建议,你在招聘产品工程师。你说你现在确实招聘产品工程师。现在不是每个人都有机会在一个产品工程师的角色中工作。但是,如果你是一名软件工程师,你可以做些什么来培养这种产品意识,让你的工作更接近产品工程师的工作?

Original English

Gergely Orosz: >> Okay. Um and as closing advice you are

hiring for for product engineer. You

said that you actually hire for that

now. Not every might have the

opportunity to work in a role that is a

product engineer right now. But if

you're a software engineer, what are

things that you can do to grow this

product sense to be to to change your

work to be closer to what a product

engineer does?

Tuomas Artman: 我的意思是,这完全是关于,嗯,更接近你的客户。如果你在一个公司工作,或者只是构建东西。就像,学习的最好方法是,你亲自动手,尝试一些东西,为自己构建它。这是最容易的部分。 um,你可以考虑,就像,你需要什么。你可以构建它,然后你就能从中学到经验。然后你把它发布到全世界,希望其他人也能使用它,然后你知道,你就有了你的第一个客户,你可以从中获得经验,你知道,无论你构建的是正确的东西还是不正确的东西。 um,当然,也有大量的文献,你可以,你知道,阅读 Apple 的人机界面指南,那是一本最好的书, um,如果你想做好用户体验,嗯,只要遵循他们说的去做,你就会做得很好。 um,是的,那就是那两件大事。

Original English

Tuomas Artman: I mean, it's all about uh

getting closer to your customers if

you're working at a company or just

building stuff. Like the best way to

learn is to actually you get your hands

dirty, try something out, build it for

yourself. That's the easiest part. um

you can think about like what you need

you can you can build it and you learn

from that experience then you ship it to

the world hopefully somebody else uses

it as well and then you know you've got

you know your first customers that you

can get experience from of you know

whether you're building the right thing

right thing or not um obviously there's

literal lit literature as well you can

you know read through you know Apple's

human interface guidelines that's the

best book um if you want to do sort of

good UX um just follow what they say and

you'll be good um and yeah those are

those are the two big things

Gergely Orosz: 太棒了。嗯,Thomas,非常感谢你。

Original English

Gergely Orosz: >> awesome Well, Thomas, thank you so much.

Tuomas Artman: 谢谢你。

Original English

Tuomas Artman: >> Thank you.

📌 文中提及的人物和组织

人物: Tuomas Artman, Gergely Orosz

公司/组织: Linear, Uber, OpenAI

产品/模型: Cloud Code, Opus 4.5

媒体/书籍: Apple's Human Interface Guidelines

关键字: ai software-quality product-engineering user-experience