I believe the scarcest resource in software engineering today is not speed - it’s judgment.
AI writes code faster than any human ever could. But someone still has to decide whether that code is correct, maintainable, and worth shipping. That decision requires experience, context, and the kind of intuition you only build by doing the work.
I’ve spent 15+ years as a software engineer, engineering lead, and CTO. I’ve designed cloud architectures, refactored monoliths into microservices, and led teams through transformations at companies ranging from startups to Fortune 100. At IBM, I co-created and led the XP Farm framework globally, coaching thousands of developers in software crafting, TDD, and clean architecture.
Now, as CTO of Craftosphere, partner at BriX Consulting, and part of the nWave team, I focus on helping engineering teams maintain quality in an AI-assisted world - through embedded coaching, tooling, and writing about the trade-offs behind everyday software design decisions. nWave is where the coaching philosophy meets the code: an AI-augmented framework that enforces TDD, peer review, and software craftsmanship at every step.
I publish Code That Makes Sense - a newsletter for senior engineers who use AI daily but refuse to stop thinking.
Currently available for CTO advisory, technical coaching, and speaking engagements.
Outside of code: certified trek guide, motorbike rider, DIY builder, guitar player, and proud owner of four dogs.
I provide strategic technical leadership at Craftosphere, setting the company’s vision and coaching methodology. As the primary technical coach, I guide engineering teams through transformation: embedded coaching, workshops, and consulting aimed at improving both delivery and engineering culture. I publish Code That Makes Sense, a newsletter on engineering judgment for the AI era, and I’m developing an engineering quality index - an open framework for measuring engineering judgment across teams.
As a partner at BriX Consulting, I deliver Extreme Programming lectures and embedded coaching sessions focused on technical skills, team practices, and engineering morale. I also collaborate on strategic company direction and refine our coaching methodologies. I co-authored the Software Craftsmanship Dojo - a hands-on workshop program - along with the Unicorns’ Ecosystem and the BOKaRy (Body of Knowledge and Reference) framework. I’m also part of the nWave team - building an AI-augmented development framework that enforces TDD, peer review, and software craftsmanship practices throughout the development lifecycle.
I worked with decision-makers across IBM to modernize development methodologies and tooling. I co-created the XP Farm framework - not just locally in Budapest, but globally across IBM - advocating for software craftsmanship, TDD, and clean architecture as organizational standards. I established feedback mechanisms for data-driven coaching decisions and shared insights with the global developer community.
I led the end-to-end design and implementation of scalable, cloud-based software solutions. The core project was a monolith-to-microservices migration - I architected the target state, guided the team through refactoring, and ensured we maintained production stability throughout the transition.
2017 - 2019, Budapest, Hungary
I led cross-functional teams through the full software development lifecycle - architecture, implementation, testing, and deployment. I provided technical direction, mentored team members, conducted performance testing, and acted as the bridge between engineering and business stakeholders.
2013 - 2017, Budapest, Hungary
I taught Java, Spring, and software engineering at multiple training academies. I focused on practical, hands-on instruction, adapting my approach to different learning styles and experience levels. The goal was always the same: give people the foundation to build real careers as developers.
|
|
M.Sc. in Electrical Engineering - Embedded Systems specialization |
|
|
|
B.Sc. in Computer Engineering - AI specialization |
|
|
|
2002-2008
High School |
|
|
|
2000-2002
High School |
This award demonstrates a commitment to software craftsmanship, continuous learning, teamwork, the discipline to stick to daily practice, and the passion for knowledge sharing.
Special recognition for the top recipients for developing technical achievements.
This award represents the dedication and passion one has put into making CIO Hungary a better place.
Hungarian National IT Challenge (Országos IT Megmérettetés)
Hungarian National IT Challenge (Országos IT Megmérettetés)
Hungarian National IT Challenge (Országos IT Megmérettetés)
Hungarian National IT Challenge (Országos IT Megmérettetés)
Integrated Development Environment for a Custom Soft-Core Processor
Push Notifications for Sensor Networks with Internet Connection
A case study about a real registration method that grew to 19 parameters and how we made it maintainable using the Pipes and Filters and Strangler Fig patterns.
Frontend testability is a property of the design, not the framework. Pull the business rule out of the component and ‘hard to test’ stops being true.
Coverage counts the lines that ran, not the lines verified. A method can reach 100% with its rules unverified. Mutation testing measures the gap.
Most refactoring never needed a sprint or a backlog item. It fits inside the feature branch we already have open, as long as the commits stay separate.
Your team lead isn’t against quality. His “no” to refactoring is due to delivery pressure and risk, not indifference, and here’s how to argue in his terms.
“Just ship it” isn’t wrong, it’s unpriced. The post is about what shipping without design actually costs, in three numbers a manager already tracks.
Tech debt is two opposite things sharing one name: an intentional shortcut we chose, and an accidental mess nobody intended.
A service class isn’t big because the domain is hard, but because the behavior never went home. A domain name holds the line that the Service suffix never could.
A feature flag that branches on a string is a type code in disguise. Replace it with polymorphic dispatch, and the generated wiring makes a flag safe to delete.
A transfer between two accounts fits in neither. The DDD move: promote the verb to an aggregate, then let event sourcing calculate the balances.
Decorator stacks optional layers, Chain of Responsibility orders guards that short-circuit. Two more ways to slim a heavy aggregate without going anemic.
Aggregates get heavy when you keep stuffing rules in. Specification, Policy, State, and Strategy move behavior out without sliding into the anemic-domain trap.
Domain services decide, application services orchestrate: one rule splits any XService into a pure policy and a rule-free use case.
Hexagonal architecture doesn’t guarantee a good domain. The anemic-model trap: fields inside, rules outside, and the encapsulation promise quietly broken.
Why architecture discussions keep collapsing into schema arguments, and the order of operations that puts domain discovery before the database.
User stories, acceptance criteria, and BDD scenarios are layers of precision, not rivals. Walk each story down the ladder before the code catches up.
Customers won’t learn your jargon and they shouldn’t have to. The translation burden sits with developers - here are the tools that actually close the gap.
Balancing Code Health and Feature Delivery
When the Type-Code Affects Behavior And It Should Change at Runtime
We’ve previously dived into the complexities and maintenance challenges of switch-case and saw a refactoring technique for simple scenarios. Today, we’ll raise the bar a bit and focus on situations when our type code affects behavior. We’ll use pets to demonstrate the concepts.
Explore ideas how to prevent a codebase’s quality from decreasing.
Learn that refactoring is a natural and essential part of a software’s evolution
A quick and practical introduction to programming to an interface.
Learn about object-oriented and functional programming and discover that they are not mutually exclusive.
Learn what polymorphism is with examples.
Learn the advantages and disadvantages of the configuring a mock object the when().thenXxx() or the doXxx().when() way.
Explore the core concepts behind the object-oriented programming.
Learn how to map a single Java entity to multiple database tables using JPA.
Explore how to configure your Java applications using command-line arguments.
Explore the properties and representation of composition, aggregation, and association in Java.
Learn how Epsilon works, and explore the common use cases.
Explore how Z Garbage Collector manages to keep low pause times on even multi-terabyte heaps.
Learn about the peek() method and explore the lifecycle of a stream.
Explore multiple ways of handling dynamic JSON objects with Jackson.
Explore several ways to remove leading and trailing characters from a String.
Learn how to model a many-to-many relationship in Java using JPA
Learn how to implement a Binary Heap and Heap Sort in Java.
A quick tutorial to using JPA Criteria Queries using Spring Data JPA.
In this tutorial, we’ll see multiple solutions to efficiently removing all occurrences of a value, describing the pros and cons.
Learn how to manipulate the HTTP response using the ResponseEntity class.
Have a look at the @ResponseStatus annotation and how to use it to set the response status code.
Explore the most commonly used Spring core annotations.
Explore the most common Spring scheduling annotations.
Explore the main annotations you can use to handle HTTP requests and responses in Spring MVC.
Explore the Spring Boot Annotations.
Learn about the most important annotations we need to handle persistence using the Spring Data project
Take a look at how to work with boolean values in Thymeleaf.
