Fifteen thousand lines, all of them after one in the morning

🌙 Why the whole day is one entry

Two hours to the office. Two back. And the evening.

What made it into the history is those two lines, both of them past one in the morning.

Not because nothing was happening before that. Plenty was. It just wasn't results, it was experiments: trying tools, poking at an environment I don't know, watching what actually happens when you press something.

Committing that is noise.

Not history — noise inside the history. I have nobody to report to, and I don't need a trail of breadcrumbs to find where we took a wrong turn later: I wasn't the one turning. And turning the wrong way was part of today's job.

So the first commit of the day is at 1:38. The whole lot in one go.

I'll sort it out tomorrow.

🧰 My side of the laptop

A late timestamp in a commit history reads as heroism. It isn't.

The night is what was left over.

Four hours of travelling and the entire evening went on tools.

I'm a front-end developer. My daily tool is WebStorm and it has saved me more than once. The paradox of 2026 is that half of what I loved it for I no longer open. The need to type code by hand falls away — and the conveniences invented for somebody who types by hand fall away with it.

But the app is for the Mac. And for the Mac, it's Xcode.

Right then, I think. Now I'm a real Apple developer.

It feels like moving from Windows to macOS.

A lot of it works differently, and the problem isn't that you don't understand — it's that you don't know where the handle is. A kitten with its eyes still shut, feeling around for how this thing is supposed to switch on.

Fine. Not rocket science.

The problem turned out to be somewhere else.

I tried to attach an agent to it.

It didn't attach.

The current models didn't, to be exact. Or maybe I just didn't work it out: from the outside, "it doesn't work" and "I couldn't find where you turn it on" look exactly the same.

Either way, taking the fortress at a run ended in — well, let's say nothing. No magic.

The conclusion is short and unflattering. You have to know your tools. Even fifteen years into the industry.

Especially fifteen, probably.

I exhaled and started WebStorm back up. With Claude beside it, as a widget.

It got clearer.
It did not get easier.

My M1 can't carry that crowd.

And that's where I caught myself on a question I'd never asked before.

Do I actually need it any more?

Local history, heavy refactoring, the whole JetBrains arsenal — those are tools for a person who writes code by hand. I don't write by hand. I read, I correct, and I decide what it ought to be.

Maybe it's time to give VSCode a go.

My scepticism about it is old. It's light — and a lot of it isn't in there. To get it in there you need extensions. And an extension is somebody else's code that I install into my editor and know nothing about.

So it always sat somewhere in the background. I walked up to it a couple of times and we never got on.

But what I want from an editor today is different, and it's short:

• light
• the newest models
• nothing on top, only what I trust

And against that list it suddenly wasn't a compromise, it was the answer.

Better than the WebStorm I'm used to. That one I did not see coming.

So the evening ends like this.

Xcode to read the code.
VSCode to work.

Not the arrangement I sat down for. But it works.

And only after all that does the part you can see in the commit history begin.

🏗️ What actually happened

Remember the six thousand lines from last time? Six task files, milestone zero to milestone five?

Zero and one are closed today.

Zero is the frame: the project, the data models, a first window. One is the app itself — the canvas, tabs, blocks you can move and resize, text inside a block that edits in place, and the one thing this whole business was started for: click, and the line is on the clipboard as plain text.

The prototype, in other words. Only native, and on my own machine.

Nine thousand lines in the first commit.

And a minute later the second one, which matters more than it looks.

📋 A promise that turned out to be two lines

The first of the three pillars on the landing page says: text always pastes as text. No inherited fonts, no colours, no invisible formatting to clean out afterwards.

It sounds like a feature. In code it looks like this:

pasteboard.clearContents()
pasteboard.setString(text, forType: .string)

Clear it. Put the string in. Done.

The difference between this app and the one that wrecks your email isn't that something was added here. It's that there is nothing here to add. The others put several representations of the same piece on the clipboard at once, so that whatever receives it can pick the richest one. This puts one in and refuses to put the others.

The main property of the product turned out to be a refusal, not a capability.

I suspect that will keep happening.

📎 The commit called "Add instructions"

Six and a half thousand lines, and I didn't write one of them tonight.

I copied the documents into the project folder. The strategy, the requirements, the milestone plan, all six task files — everything that was already sitting one floor up, in the same repository.

Copied. Didn't move.

And I know how that looks. Duplication gets your knuckles rapped, and quite right too.

But it buys something I didn't have before: a predictable address.

Everything that matters, in one place. No keeping it in your head that the strategy is here, the requirements are a floor up and the tasks are off to one side somewhere. Open the project folder and everything you work with is in it.

This is where the theory from last time met practice for the first time. I said the specification had stopped being a document and become input. Input goes where the work happens, not where it looks tidy.

Documentation isn't a shelf any more. It's context, and context has an address.

Although the address came out as more than one.

There are now three sets of those same files in the repository, byte for byte. The original, one floor up. The second was put there by the commit a minute earlier, inside the app itself. The third is this one.

"Everything important in one predictable place" became three predictable places inside of a minute.

🔌 Engineer honesty moment

Now open the source folder.

jpasteModelsBlock.swift
jpasteModelsTab.swift
jpasteViewsCanvasBlockView.swift
jpasteTestsBlockViewModelTests.swift

See what happened?

That was supposed to be Models/Block.swift. Views/Canvas/BlockView.swift. Folders, a tree, structure — like any project anywhere.

Instead the path became part of the name. The directories were never created, and the lot landed in one folder with their names fused together.

Twenty-two Swift files. Not one directory.

And a separate joy: the test files are sitting inside the app. Not in a test target — right there, next to the models.

Fifteen thousand lines, and a folder that looks like somebody sneezed into it.

And the cherry. PasteboardService.swift — the one with the two lines this whole thing exists for — is in the tests folder. Its tests are in the app.

They swapped places.

Last time I was showing off a document about which patterns are forbidden and committing litter from Finder next to it. This time the scale has grown: now nothing is where it belongs.

And here's the part I properly enjoy. I spent the evening deciding which tool to work in. And in not one of them did I look at the folder structure.

Oh, and one more thing. Tonight's first commit is titled "Start iOs development".

This is a Mac app.

Well. Ten years of front-end don't evaporate: Apple means iOS.

It can sit there like that for now.

🕳️ We're digging the pit

I know a few languages. JS every day, Go and Java when the job calls for it, C++ in a previous life.

Swift is its own universe. Different rules of the game, different best practices, different habits among the people who live in it.

It reads.

It doesn't write.

And honestly: it's not as if I was entertaining myself reading code. At some point I caught myself on a different feeling — project manager. Or the owner of my own startup.

Product sense and a technical background will come in useful when the polishing starts. Today isn't about that.

Today is about understanding how all of this works, and getting hold of something. Anything. Raw, buggy, not working — but existing. And packaged correctly from the start, so there's something to work with tomorrow.

(The packaging, as you've already seen, went otherwise.)

Last time I opened with: first you think about the foundation, then there's a plan, and only then does anybody pick up a tool.

Right. We're not building yet. We're certainly not glazing the windows.

We're digging the pit the foundations go in. Roughly to the drawing, trying not to do anything stupid.

The master digger here isn't me. I'll know if we've gone somewhere we shouldn't — but that isn't my function.

And for an arrangement like this, honestly, it's the best time in my whole career.

You used to have to hire people for this seat. A team, specialists — and they could also not know something.

What's in that seat now is a know-it-all that sometimes walks off in the wrong direction.

(People, obviously, never do that.)

🎯 What exists now

For the first time in this story there's a thing, not an argument.

Twenty-two Swift files. Models, view models, views, a clipboard service and nineteen tests.

And a log of three hundred and forty-three lines, in which the night describes itself.

✅ M0 COMPLETED
✅ M1 COMPLETED

Session duration: ~3-4 hours
Files created: 22
Tests written: 19
Lines of code: ~1500+

Status: READY FOR REVIEW AND TESTING

Fifteen hundred lines, says the log. Nine thousand in the commit.

But that isn't the important part of it. The important part is right at the end, in a section of its own:

TESTING CHECKLIST FOR MORNING

Build & Run:
1. Open Xcode project
2. Cmd+B - should compile with ZERO errors/warnings
3. Cmd+U - run all tests (should pass 19 tests total)
4. Cmd+R - launch app

And the last line of the file:

Good morning and good luck! 🚀

Three or four hours. The first time in my life I've properly opened Xcode — and I close the laptop with two milestones done and a checklist for the morning.

Don't read that as being about my speed. It's about what changed in the tools.

What comes of this, I don't know.

If nothing does, it's one more dead repository on the account. Everybody has those.

If something does — we'll see which way this is blowing, what I learn from it, and what I turn out to be able to make.

💬 A question

When did you last open an IDE for a language you don't write in?

My answer is today. And it turns out reading is enough.

What stopped you last time — the language, or the thought that it would take a month 👇

Next I'll have to look at this in the light of day.

I suspect I won't like it 😉