DEV Community: Serguey Asael Shinder

The Future Is Mostly Old Code

Serguey Asael Shinder — Sat, 05 Sep 2026 08:16:10 +0000

Picture the next ten years
and you probably picture
something new.

New language.
New paradigm.
A green field
and a clean start.

That is not what is coming.

What is coming
is the code that already exists,
still running,
with more of it every year.

The bank still runs it.
The hospital still runs it.
The thing your favourite new app
quietly calls
at the last step of checkout
still runs it.

Nothing gets replaced
as often as we announce.

It gets wrapped.
It gets fronted.
It gets a new interface
and the same heart.

So the valuable skill
is not only building the new.

It is walking into something
large, undocumented,
and load bearing,

and changing it
without breaking
the world that depends on it.

That is a craft,
and almost nobody teaches it.

It looks like reading
before writing.
Like finding the seam
instead of the rewrite.
Like adding one test
around behaviour you do not understand
just to hold it still
while you move.

Like asking who is upstream,
who is downstream,
and who will call at midnight
if you are wrong.

The people who can do this
will not run out of work,

because every year
adds another decade
of somebody else's decisions
to the pile.

And there is a second half,
which is about you.

Everything you write this year
becomes exactly that
for somebody else.

The clever thing
will be the confusing thing.
The undocumented choice
will be the load bearing mystery.
Your Tuesday shortcut
becomes their Thursday outage.

You cannot make it immortal.

You can make it legible.

Say why in the commit.
Leave the reason next to the code.
Delete what nothing calls,
so the map matches the ground.

The future is not a clean start.

It is other people's code,
and yours,
still running

long after the reason
has been forgotten.

Write like someone
will need to understand it
without you.

– Serguey Asael Shinder

Leave Yourself a Note Before You Stand Up

Serguey Asael Shinder — Sat, 05 Sep 2026 08:15:38 +0000

The meeting starts in two minutes.

You are deep in something.
Three files open,
a theory half formed,
one hand on the answer.

You close the laptop
and walk away.

When you come back,
you are not where you left.

You are at the trailhead again,
reading your own code
like a stranger,

trying to remember
why you opened that file,
what you had ruled out,
what the next step was
supposed to be.

Twenty minutes to climb back
to where you already stood.

That climb is the real cost
of interruption.

Not the meeting.
The re-entry.

And the strange thing is
that you can pay almost none of it
for the price of forty seconds.

Before you stand up,
write the note.

Three lines at the bottom
of the file you are in,
or in a scratch pad
that never leaves your screen.

What am I doing.
What have I ruled out.
What is the very next move.

Not a status report.
A rope back into the cave.

Working on the null case
in the parser.
Ruled out the config,
it is the tokenizer.
Next, add a failing test
for an empty input line.

That is it.

Come back after the meeting,
read four lines,
and you are inside the problem
in a minute
instead of half an hour.

Do it at the end of the day too,
which is the interruption
you schedule on purpose.

Never stop at a clean finish
if you can help it.

Stop mid sentence,
with a note,
and tomorrow morning
you will not spend your best hour
deciding what to do.

You will already be moving
while the coffee is hot.

There is a second gift here.

Writing the next move down
forces you to know
what the next move is.

Half the time you will discover
you did not know,

and that discovery,
at forty seconds,
is much cheaper
than discovering it
after another hour
of confident wandering.

You cannot stop
being interrupted.

You can stop paying
full price for it.

– Serguey Asael Shinder

Quitting the Wrong Thing Is Not Failure

Serguey Asael Shinder — Sat, 05 Sep 2026 08:15:06 +0000

You already know.

You have known for weeks.

The project is not going to work,
or it is going to work
and you will hate maintaining it,

and every morning
you open it anyway
because stopping
feels like admitting something.

Admitting what, exactly.

That you learned something
that cost time.

That is not a confession.
That is just what learning costs.

The trap is simple
and it is very old.

The more you have put in,
the harder it is to walk away,

which means the worst investments
hold you the tightest.

You do not owe a project
the rest of your life
because you gave it
the last six months.

The months are gone
whether you continue or not.

The only real question
is where the next six go.

But be honest about
which kind of hard
you are in.

Some things feel bad
because they are almost done
and the last ten percent
is always tedious.

That is not a reason to quit.
That is the tax on finishing,
and paying it is the whole skill.

Other things feel bad
because you no longer believe
the thing at the centre.

The users are not there.
The idea was wrong.
You changed
and the plan did not.

That is a reason to quit,
and no amount of discipline
will make a wrong direction
into a right one.

Discipline applied to a dead idea
is just a slower way
of losing the same time.

So make it a decision,
not a drift.

Give it a date.
Name what would have to be true
by then.

If the date arrives
and none of it is true,
stop cleanly.

Write down what you learned
in plain sentences.
Keep the parts worth keeping.
Close the tab.

Then notice something.

The energy that comes back
is not new energy.

It was yours the whole time,
paying rent on a thing
you had already stopped believing in.

Finishing matters.

Finishing the wrong thing
is just tidy waste.

– Serguey Asael Shinder

The Tape Does Not Flatter You

Serguey Asael Shinder — Sat, 05 Sep 2026 08:14:34 +0000

You can play it.

You have played it
forty times this week
and it felt good
almost every time.

Then you press record,
play it once,
and listen back.

And it is a different song.

The tempo drifts
in the bar where you relax.
The chord change is late.
That run you love
is a smear.

The tape is not cruel.

The tape is just the first listener
who is not also
the person playing.

While you play,
you cannot hear it.

You are busy.
You are steering.
Your ears are two seconds behind
your hands,
and your brain kindly fills in
what you intended
over what you did.

That gap is where
years of practice go to hide.

You rehearse the intention
and never meet the result.

So make the result cheap to see.

Phone on the table.
No setup.
No good microphone.
No waiting until
you deserve to record.

Play the thing once,
all the way through,
mistakes included.

Then do the hard part,
which is not playing.

It is sitting still
and listening to the whole take
without reaching for the instrument,

without starting again
at the first ugly moment,

because the instinct to start again
is what has kept you
from ever finishing
anything.

Write down one thing.

Not five. One.

The bar that rushed.
The note you never let ring.
The transition you fumble
every single time
and have been quietly deciding
does not count.

Fix that one thing.
Record again tomorrow.

Keep the takes.

Not to admire them.

To hear, in a month,
that the bar you fixed
stayed fixed,

which is the only proof
that practice is practice
and not just
time spent holding
an instrument.

This is not a music trick.

It is the same reason
you read your own pull request
before a human does,

the same reason
you watch the recording
of the talk you gave.

The performance in your head
is always a little better
than the one in the room.

The tape closes that distance.

Nobody enjoys the first playback.

Everyone who got good
kept pressing record anyway.

– Serguey Asael Shinder

The Skill You Stop Practising Is the One You Lose

Serguey Asael Shinder — Sat, 05 Sep 2026 08:14:02 +0000

The machine is good now.

Good enough that the part
you used to struggle through
is finished before your coffee.

That is a gift.

It is also a bill,
and the bill arrives late.

Because the struggle
was not waste.

The struggle was the gym.

Every time you sat
with a confusing stack trace
and refused to stand up,

you were not just fixing a bug.
You were building the thing
that lets you fix
the next one faster.

Hand that away every day
and something goes soft.

Not dramatically.

You will not wake up
unable to code.

You will just notice, one afternoon,
that you cannot hold
the whole problem in your head
the way you used to,

that you read a diff
and your eyes slide over it,

that you accept an answer
because checking it properly
now feels like a bigger job
than asking again.

That last one
is the dangerous step.

The tool makes the answer cheap.
It does not make the judgment cheap.
And the judgment is the part
they pay you for.

So keep a practice.

Not out of nostalgia.
Out of self-interest.

Once a week,
take one problem
and do it by hand,
badly, slowly,
with the docs and your own head.

Read the library source
instead of asking what it does.

Debug one thing
without pasting the error anywhere.

Write the tricky function first,
then ask the machine
to argue with your version.

You will be slower that day.

You will be sharper
for the ten days after,

and you will notice
the confident wrong answer
that everyone else
merged on a Friday.

Use the machine for the part
that does not teach you anything.

Boilerplate. Translation.
The fourth variation
of a thing you have already learned.

Keep for yourself
the part that hurts
in the way that builds.

The engineers who thrive next
will not be the ones
who typed the least.

They will be the ones
who can still tell
when the answer is wrong.

– Serguey Asael Shinder

Your Logs Remember What You Promised to Forget

Serguey Asael Shinder — Sat, 05 Sep 2026 08:13:30 +0000

You encrypted the database.

You rotated the keys.
You wrote the privacy page
and meant every line of it.

Then, in April,
you logged the whole request body
to debug one stubborn endpoint,

and you never took it out.

Now the promise lives in the database

and the truth lives in the logs.

This is the quiet leak.

Not a break-in.
A habit.

The token in the error message.
The full user record
in the retry warning.
The card number, masked,
except in the one code path
that logs before masking.

The password
that arrived in a field
you did not expect
and got printed
because you print everything
when something goes wrong.

Logs feel harmless
because logs feel internal.

They are not internal.

They are copied to a search cluster,
shipped to a vendor,
retained for a year
by a policy nobody remembers writing,

and readable by every engineer,
every on-call contractor,
and anyone who ever gets
a single read-only credential.

You built a vault
and then narrated its contents
into a room
with the door open.

So do the unglamorous audit.

Search your logs for the shape
of the things you are afraid of.
An at sign. A bearer prefix.
Sixteen digits in a row.

You will find something.
Everyone finds something.

Then move the fix upstream
of your own discipline.

Do not ask people to remember
to redact.

Give them a logger that cannot print
the sensitive type,
a struct whose printer
returns the word redacted,
a test that fails
when a secret appears in output.

Discipline does not survive
a bad afternoon.

Types and tests do.

And shorten the memory.

The safest record
is the one that expired last week.
Retention is not a storage setting.
It is the size of the blast
when someone else
reads your logs.

Then look one step further out.

The screenshot in the ticket.
The paste in the chat channel
that keeps everything forever.
The stack trace someone mailed
to a vendor
to prove the bug was real.

Same leak.
Different pipe.

You are careful about what you store.

Be as careful about
what you say out loud
while you work.

– Serguey Asael Shinder

Your Defaults Are a Decision Everyone Else Inherits

Serguey Asael Shinder — Sat, 05 Sep 2026 08:12:58 +0000

Every setting you expose
ships with a value
you picked in about four seconds.

That value is the real product.

Because almost nobody
will ever change it.

Nine people in ten
take what you handed them
and assume it was considered.

Sometimes it was.

Often it was whatever
made the test pass
on a Tuesday.

So the timeout is thirty seconds
because thirty is a round number.

The retry count is three
because three felt brave
without feeling reckless.

The log level is debug
because you were debugging.

And now a thousand machines
run your Tuesday afternoon
as policy.

A default is not a suggestion.

It is a decision you made
on behalf of everyone
who never opened the docs.

Treat it like one.

Ask the small question
before you type the value.

What happens to the person
who never touches this.

Is the safe path
also the lazy path.

Because if safety costs
one extra flag,
you have made safety opt-in,

and opt-in safety
is decoration.

Make the careful choice loud.

Encryption on.
Verbose off.
Destructive actions
asking first.

Limits that protect the system
from an honest mistake,
not only from an attacker.

And when you truly cannot decide,
that is information too.

A default you cannot defend
usually means the option
should not exist,

or the thing should refuse to start
until someone says
what they meant.

Silence is never neutral.
It just puts the cost somewhere
you will not see it.

There is a second half to this,
and it is the expensive half.

Changing a default later
is a breaking change
wearing a very small hat.

Nobody reads the release note
that says the default is now stricter.

They find out at three in the morning,
when the job that ran quietly
for four years
stops.

So choose slowly.
Write down why.
Keep the why next to the value,
not in a document
nobody can find.

And if you must change it,
say so in the loudest place you own,
twice,
before it happens.

Flags are for the experts.

Defaults are for everyone else,

and everyone else
is most of the world.

– Serguey Asael Shinder

Teach What You Know Before It Changes

Serguey Asael Shinder — Fri, 04 Sep 2026 07:32:40 +0000

Everything you know
has a shelf life.

The framework you mastered
is already being described,
somewhere,
as the old way.

That is not a tragedy.

That is weather.

You cannot hold a tool
long enough
for it to become
an inheritance.

But there is one thing
you can do with knowledge
just before it expires,

and it is the only move
that keeps paying
after the expiry date.

Teach it.

Not in a course.
Not from a stage.

In a paragraph
inside a pull request.

In twenty minutes
at a whiteboard
with one person
who asked.

In a note in the repository
that begins
we chose this because.

Here is what happens
when you explain a thing.

You find the three places
you never actually understood,

only used.

You compress it,

and compression is
where understanding lives.

You turn a skill
into a principle,

and the principle
outlives the tool.

That is the trade.

You lose the specifics,
which were leaving anyway,

and you keep the shape,

which is what
you were actually good at
the whole time.

The syntax dies.

The reason it was good
moves house
into whatever comes next.

There is a quieter return
as well.

The person you taught
remembers.

Ten years out,
the map of who trusts you
looks almost exactly like
the map of who you helped
when it cost you an hour
and gained you nothing.

Machines will get
very good
at handing over answers.

They will not be
the person who sat with someone
and noticed
which part
they were afraid of.

So write it down.

Explain it badly
to one person today.

Do it before the tool changes,

because after it changes
you will not remember
what was hard about it,

and what was hard about it
was the whole gift.

Knowledge you keep
depreciates.

Knowledge you hand over
compounds

in someone else's account,

and in yours.

– Serguey Asael Shinder

Close the Tabs You Are Pretending to Read

Serguey Asael Shinder — Fri, 04 Sep 2026 07:32:08 +0000

Forty-one tabs.

You cannot read the titles anymore.

They are slivers now,
a row of little icons,
each one
a decision you deferred.

None of them are open
because you are reading them.

They are open
because closing one
feels like admitting
you never will.

So the browser became
a museum
of intentions.

Every tab
is a small debt
with a soft voice.

You are not giving them
attention,

but you are paying rent
on all of them,

because your eyes
cross that row
a hundred times a day
and something in you
does the arithmetic.

Same with the pinned messages.
Same with the eleven drafts.
Same with the folder
called read later,

which has never once
been opened later.

None of it is work.

All of it is
the feeling of work,

which is heavier
and pays nothing.

Attention is not a tap
you turn.

It is a room,

and you have furnished it
with strangers.

So do the ugly thing.

Close them.

Not triage.

Close.

The one you truly need
you will find again
in eight seconds,

because that is what
the whole internet is for.

The rest were never a plan.

They were a mood
you left running.

Keep one list,
somewhere boring,
where things go
to be decided
instead of avoided.

If it matters,
it earns a line and a date.

If it doesn't,
it earns nothing,

and nothing
is a valid answer.

Most of what we call
a backlog

is a list of things
we could not bring ourselves
to refuse
out loud.

You will feel
a small panic
as they go.

Sit with it.

That panic is the size
of the load
you had been carrying
for free.

Then look at
the one window
you left open.

Notice how quiet it is.

That is not emptiness.

That is capacity,

which you had all along,

rented out
to forty things
you were only pretending
to read.

– Serguey Asael Shinder

Ask Sooner Than Feels Respectable

Serguey Asael Shinder — Fri, 04 Sep 2026 07:31:36 +0000

You are four hours in.

Same error.
Same three tabs.
Same page of a document
you stopped reading
and started staring at.

The cursor blinks
at about the same rate
as your confidence
leaving the room.

Someone twelve feet away
has seen this exact thing
and could end it
in ninety seconds.

You don't ask.

Because asking at hour four
feels like admitting
you should have asked
at hour one.

So you keep paying,

to protect a story
about the kind of person
who does not need help.

Nobody is grading
the hours you burned alone.

They are looking at
whether the thing works,
and whether you are pleasant
to build with.

Suffering in silence
scores zero
on both.

There is a version of pride
that looks like diligence
and works like a leak.

So set a rule,
and let the rule be brave
so you don't have to be.

Thirty minutes
of real trying.

Then write down
what you tried,
what you expected,
what happened instead.

Half the time
writing that note
solves it,

and you never send it.

The other half,
you send it,

and what you sent
is not
I'm stuck, help.

It is a small map
of a place
you already searched,

so nobody
wastes the trip.

That note costs you
five minutes

and buys you a reputation
for being easy to help,

which is quietly
one of the most valuable things
you can own here.

There is a second thing
hiding in here.

The senior
you are afraid to bother
usually wants to be asked.

It is the one part of the week
where they get to be
plainly useful
for ninety seconds.

Asking early
is not weakness borrowed.

It is time
handed back to the team.

And the person
who asks cleanly at thirty minutes
learns four times faster
than the one
who suffers beautifully
for four hours.

The struggle
was never the tuition.

It is just
the late fee.

– Serguey Asael Shinder

Finish the Song That Nobody Asked For

Serguey Asael Shinder — Fri, 04 Sep 2026 07:31:04 +0000

You have forty beginnings.

Eight bars each.
All of them promising.
None of them done.

I know this
because so do I.

Beginnings are cheap
and thrilling.

The first idea arrives
already sounding
like the record.

Then comes bar nine,

where the idea has to decide
what it actually is,

and suddenly
starting a new one
feels like inspiration

instead of what it is,

which is running.

A beginning promises.

A finished thing
has to deliver,

and delivery is where taste
gets embarrassed in public,

even if the only public
is you at midnight
with headphones on.

Nobody is waiting
for this song.

No deadline.
No client.
No crowd.

That is exactly why
finishing it matters.

The unfinished song
teaches you nothing
about endings,

and endings
are the whole craft.

How to leave.
What to drop.
Which promise from bar one
you have to keep
so the last minute
doesn't feel like a lie.

You only learn that
by going all the way through
something mediocre.

The middle is unglamorous.

It is arrangement,

and arrangement is just
a long series
of small subtractions

made by someone
willing to be bored
on purpose.

So pick one.

Not the best one.

The one you can bear
to hear
two hundred more times.

Give it a bridge
that is worse
than you wanted.

Give it an ending
that is too simple.

Mix it badly
and call it mixed.

Perfection is a polite word
for stopping early
and blaming the standard.

Then put it down,
finished,
where you can see it.

That done thing
is a teacher.

It shows you,
without argument,
exactly which skill
you do not have yet.

The forty fragments
are just a loud room
full of people
talking about a trip.

Nobody asked for this song.

Nobody asked
for most songs.

Finish it anyway,

and notice
that the next beginning
arrives
already knowing
how it ends.

– Serguey Asael Shinder

Never Let the Model Pick the Problem

Serguey Asael Shinder — Fri, 04 Sep 2026 07:30:31 +0000

It will answer anything.

That is the trap.

Ask it a bad question
and it will not say
this is a bad question.

It will build you
a complete,
well-documented answer
to the wrong thing,

and it will do it
in nine seconds,

which is exactly long enough
to feel like progress.

The machine is very good
at how.

It is in no position
to know what,

or whether,

or for whom.

It was not in the room
when the customer
said the quiet thing
at the end of the call.

It does not know
which of your three problems
is the one
actually costing money.

It cannot smell
that the feature you asked for
is a workaround
for a policy
nobody wants to change.

That part is yours.

The model optimizes
the answer.

You are paid
to optimize
the question.

Choosing the problem
is the last job
you should ever hand over,

because everything downstream
inherits it.

A fast, elegant, tested solution
to the wrong problem
costs more than nothing,

because now
you maintain it forever.

Nobody ever apologized
for a wrong answer.

They apologized
for the six weeks
spent building it.

So do the slow part first.

Write the problem
in one sentence,
in plain words,
without naming a technology.

Say who hurts.
Say how you would know
it stopped hurting.
Say what you will not do.

Then read it back
to a person
who has to live
with the result.

If they wince,
you have found the real problem,

and it was never
the one on the ticket.

Then bring the machine in
and let it be brilliant
inside your fence.

Use it to draft.
Use it to argue.
Use it to find
the thing you forgot.

Just don't let it
choose the destination
because it sounds confident
about the road.

It has read everything
ever written
about the map.

It has never once
been to your town.

Keep the wheel.

Let it read the map
out loud.

– Serguey Asael Shinder