About
I help FinTech founders figure out what's really blocking their growth — then fix that…
Activity
5K followers
-
Alex Fedorov shared thisThe hardest question at the XP Unconference last year did not get an answer. It came out of a session titled "How to Detect Thinking by Humans", whose second half asked when that even matters. Somebody in it put the problem like this: "In the past, we used to use written documents to figure out if someone has thought about a problem. Now we're saying generate these documents with AI. How do I know that someone has thought about a problem? We can't use the document anymore." Think about how much of your process that breaks. Design documents. Architecture decision records. Written proposals. Pull request descriptions. Every one of those was a proxy for thinking, and the proxy worked for one reason only: producing the artefact used to require doing the thinking. The artefact is now available separately from the thinking. The related finding is worse. Writing triggers thinking, and coding is where you discover what the specification missed. Remove the human from the writing and the discovery loop never fires at all. Nobody in the session had a replacement. The reframe that came closest: treat the model as an inquiry partner, not an answer machine. Have it generate acceptance criteria as multiple choice questions for a human to answer, in place of statements for a human to nod at. What else came out of the two days: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisPrompt rules do not survive contact with an agent. Architecture tests do. I watched this argued out at the XP Unconference last year, by people comparing what worked in their own codebases. The reasoning is mechanical. An agent can ignore a rule written in a prompt, and it will, because a prompt is a suggestion that gets weighed against everything else in the context. It cannot ignore a test that fails the build. So move the constraint out of the prompt and into the pipeline. ArchUnit. Dependency Cruiser. CodeScene. ESLint. Biome. A second technique from the same list works the same way. Multi-model red team and blue team: one model writes, another tears it apart. The check never comes from the thing being checked. None of that is a workaround. It is the observation that a constraint only constrains when something stops a merge. The rest of what worked in real codebases: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisOne finding survived the year. Human-friendly code is also AI-friendly. At the time it sounded almost too obvious to write down. The reason it holds is that it depends on nothing that has changed since. Not which model you use, not how you prompt it, not how much context you can buy. It is a claim about the code. The mechanism is dull, which is usually a good sign. A name that lies about what the code does forces a reader to open the body and check. It forces an agent to do the same. One behaviour spread across four unrelated files has to be found four times, by a person or by an agent, and missing the fourth breaks the change anyways. So the list has not changed. Clear boundaries. One behaviour in one place. Names that mean what they say. Tests that explain what the thing is for. Unfashionable, and it has not aged a day. Thirty sessions, and this was the one that lasted: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisA session at the XP Unconference last year was called "What Happens to Accelerate?" Do your delivery metrics still work? If AI writes in seconds what used to take days, does lead time still diagnose anything? A number that used to mean the pipeline was healthy might now mean only that the typing got faster. Most of what lead time measured was never typing. It was review queues, waiting for an environment, waiting for an approval, work sitting in a batch. If none of that moved, a falling number is reporting the one part that did. The session was left open. The direction of the risk was not: AI exposes dysfunction, it does not create it. A measurement system that was already pointing at activity and not at outcomes will keep pointing there, faster, and with more confidence behind the number. If you run delivery and you have not asked what your dashboard measures now that the expensive part of the work has moved, that is the question I would put to you. The organisers' write-up, open questions included: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisA team wired up an MCP so their agent could file Jira tickets automatically from error logs. They shut it down after two days. In the practitioner's words: "the amount of backlog that generated was insane." Nothing hallucinated. Nothing went rogue. The integration worked exactly as specified, at machine speed, against a log stream that had always held far more errors than anyone was ever going to triage. What had been holding that system together was that a human had to care enough to open a ticket. Nobody had ever written that rule down. The rule is writable. Not in one prompt, and not by anyone who has not done the triage themselves, but it is writable. Watch what the agent files for a few weeks. Every time it opens a ticket that should not exist, work out what you knew that it did not. Write that down. Then do it again, and keep going until the corrections stop. That is not prompt tuning. It is getting a judgement out of somebody's head one rejected ticket at a time, and nobody had ever needed to do it, because the judgement lived in a person and worked perfectly well there. "Worst case scenario is that it actually exactly does what you asked it to do. It's just not what you wanted." That is the argument for writing the rule down. It was never the argument against the agent. The failures are in there too: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisMost of what worked comes down to controlling what the model can see. I saw it in every technique people brought to the XP Unconference last year, all of it from their own codebases. Aggressive context clearing. Plan to markdown. Clear. Feed back only the plan. Break down the first phase. Write that to markdown. Clear again. Then implement. The reason people gave at the time is not the reason it has lasted. What has lasted is that a context compacted once erodes, and a context compacted several times erodes further, so the things that matter have to be said again. The plan on disk is how you say them again without retyping them. Hierarchical context files, one per directory level, so an agent working inside a subsystem gets that subsystem's rules and not the whole book. Sub-agents. In the room's words: "They don't need to know so much. They just need to know what they need to know." What each one narrows is the question, not the capacity. Not smaller. Narrower. So the reflex to resist is more of everything at once, not more context. A scoped worker holds an order of magnitude more than a year ago, and batching them puts large volumes through thoroughly and consistently. The other five techniques on that list: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisOnly seniors are gaining. I heard it in session after session at the XP Unconference last year. Somebody put it plainly: "The assumption that every developer in any tier gets faster is simply not empirically true." The business case most organisations wrote assumed the opposite. Uniform uplift across the whole team was the model. If the gain concentrates at the top of the seniority curve, the arithmetic behind a lot of tooling budgets is wrong and nobody has gone back to check. A two to three year hiring gap for junior and mid-level engineers already exists. "The industry will pay for this", five to ten years out. The management logic that produced the gap is easy to state and hard to argue with inside a quarter. Speed is everything. Juniors are slow. We can skip them. That logic never prices what it is giving up. "One key thing junior developers bring to the table is a fresh view. They are not tainted by bad biases." Nobody there landed a fix. The trade is being made right now, in most organisations, and almost nobody has written it down. The full write-up, careers and hiring included: https://lnkd.in/diqs7ACw
-
Alex Fedorov shared thisFor fifteen years I won this argument with cost. Somebody wanted a plugin system nobody had asked for, and I could say: that is three weeks we do not have. It worked. It was also the weakest argument I had, and I did not notice until it stopped working. An agent builds that plugin system in twenty minutes now. So if cost was your case for building only what you need, your case is gone. Here is what is missing: Building was never the expensive part. Carrying was. Repairing was. Neither got cheaper. Martin Fowler priced this properly years ago. What you save by building early has to beat the cost of carrying the thing until the need arrives, plus the cost of repairing it when the need arrives in a shape you did not predict. Exactly one term in that sum collapsed. Repair is the term that decides it. A wrong abstraction has to be dismantled before it can be replaced. An absent one only has to be added. Which leads somewhere I did not expect. If a capability can be generated in an hour, at the moment the need is real, in the shape it arrived in, then not building it today is worth more than it used to be. Cheap creation did not retire this maximum. It made it bind harder. One more thing, for the CTOs reading. Your executor trained on mature codebases, so it emits configurability, interfaces and extension points by default, on tasks where nobody asked for any of it. Unrequested generality used to be an ambition somebody had to defend in planning. It is now the starting position, and it arrives at volume. You will not catch that in review. Review does not scale with what an agent produces in a week. Refuse it in the commander intent. Say what you want, and say what you do not want built. The plugin architecture with one plugin. The abstraction layer over the only database you will ever have. None of it got cheaper to own. It only got cheaper to produce, which is why there is suddenly so much more of it. #engineeringleadership #softwarearchitecture #technicaldebt #cto
-
Alex Fedorov shared thisTonight in Berlin: How should we train new software professionals in the age of AI? Agentic AI can make senior developers remarkably productive. It gives a boost to junior developers too, however… Are juniors still gaining the experience and judgment they need to become tomorrow’s seniors? Which traditional skills remain essential? And which new skills should replace those that AI is making less relevant? I’m organizing an XTC Berlin event tonight to explore these questions. We’ll begin with a presentation, split into small discussion groups, and then come together to share what we learned. The focus is software engineering, but professionals from product, design, operations, business, and other fields facing similar challenges are very welcome. Join us: https://lnkd.in/dUthTFRK #SoftwareEngineering #ArtificialIntelligence #EngineeringLeadership #FutureOfWork #Berlin
Alex Fedorov replied to a comment
4w
Dusan Odalovic for more complex plans, there is even a need to reconcile the actual implementation back to plan with more adversarial agents.
Alex Fedorov replied to a comment
1mo
Alex Fedorov writing this in so much detail, because I had EXACTLY the same issue today
Experience & Education
Licenses & Certifications
Publications
-
Object Oriented Design. Important Things
tddfellow.com
See publicationThis is a brief talk about Object Oriented design, that I gave at Brainly GmbH on my demo day. It is mostly personal opinion and based on my expertise. It covers such things as:
* Importance of OO features
* Coupling
* TTD
* Actor Model
* Definition of done for the code
* Conclusions -
Design by Contract in Ruby
tddfellow.com
See publicationThis is a brief talk about design by contracts concept and its implementation in Ruby language through library `contracts.ruby`, that I gave at RUG-B Mar 2015 Meetup.
Design by Contract allows one to do defensive programming in very elegant fashion, allows to set contracts on methods (expectations on input - arguments; and on output - return result) and invariants on classes. This allows to reason about code much much better.
Courses
-
Fred George OO Bootcamp
-
-
Scrum Master Course
-
Projects
-
rack-reverse-proxy
- Present
-
active_record.cr
- Present
See projectActive Record Pattern implementation for the Crystal Programming Language.
-
contracts.ruby
- Present
Design by Contract implementation for Ruby Language. Joined the project as a co-maintainer.
Other creators
Languages
-
English
Full professional proficiency
-
German
Limited working proficiency
-
Ukrainian
Native or bilingual proficiency
-
Russian
Native or bilingual proficiency
Recommendations received
2 people have recommended Alex
Join now to viewOther similar profiles
Explore more posts
Explore top content on LinkedIn
Find curated posts and insights for relevant topics all in one place.
View top contentOthers named Alex Fedorov in Germany
7 others named Alex Fedorov in Germany are on LinkedIn
See others named Alex Fedorov