Tag: software development

Posted on
by

We are in a situation where every company is looking only for experienced and senior software engineers nowadays. Since my career started, this is maybe the hardest moment to find a job if you are starting your career as a software engineer. There are several factors behind this situation that I will mention to explain why, and then will also focus on some ideas for juniors on how to gain experience and what is important so they can be valuable to companies.

Lowest amount of investments in the IT field in recent years (post 2022)

Venture Capital Funds shifted their model from looking for companies with potential for growth to companies with strong business models and traction. There were also decreased volumes of money because of the economic recession, the war in Ukraine, and money being redirected back to traditional businesses due to the recovery of “business as usual”. This is leading companies to tighten their belts and not expand their teams at the pace seen in the last 15 years. This has been felt very strongly since the beginning of 2023.

Shift in skill expectations driven by the IT revolution

The traditional learning path has collapsed. In the past, juniors were learning by fixing bugs, working on small features, and through repetition, but now that is done by AI. The level of abstraction has increased to a level where senior engineers are reviewers of AI output and can use a combination of frameworks, SaaS, and PaaS platforms to minimize or even remove all low-level tasks. They are becoming architects and orchestrators of AI-generated code and platforms. So from “Writing code“, the needed skill now is “Problem Solving“, combining architectural knowledge, good AI prompting, understanding business needs, and seeing the bigger picture while thinking about how to provide a solution to the client.

Oversupply of entry-level talent

Over the last decades, it became very popular to be a software engineer, which led schools, universities, and academies to put many people on the market. They were already competing for companies’ attention in recent years, and now with the drop in demand, it further increases the barrier to entry.

How to overcome this and enter the market if we love software engineering?

There are several things that could help you succeed, and this advice is not only for today’s situation but is generally the right way to succeed in this dynamic industry. I also personally believe this approach is applicable to most other industries.

Participate in non-paid projects and initiatives

Start participating in initiatives outside of university/academy. This could be any kind of non-profit initiative or project. There are multiple foundations and NGOs that are looking for volunteers. This could be the first place where you can gain valuable experience. Of course, it may not be the best, but I believe there is no bad experience— even wrong decisions are experience that make us better people and specialists. You have two options here: you can find a local initiative that gives you not only experience but also networking and new connections that could support your career growth. The second option is to find a remote NGO to join, which is also a good option as you can improve your foreign language and remote work skills.

Check if there are local events in the industry you are trying to enter. These could be hackathons, seminars, conferences, or discussion groups—try to participate in as many as you can. One tip: if some of the conferences are paid, write to the organizers and ask for a free pass—you are a student and trying to save money. Another tip: many of these conferences have calls for volunteers at the beginning (I know this is not programming, but believe me, this is the right way).

Companies often have open days or participate in career festivals. These are places where you can speak with potential coworkers or future managers. Be open, positive, and open-minded. Don’t start with “I am looking for a job”, but ask what they are working on, talk about your projects and interests, and focus on positive outcomes of what you are building. Before going to the event, research the companies that will be there—check their websites, projects, and managers. It is possible to meet some of them at the event.

Work on your pet project

As soon as you have some programming skills, think of a problem to solve—it could be your parents’ business, a friend’s need, or something for the community. If you start working on something for the community, put it in a public repo and see if more people can contribute. Now, with the potential of vibe coding, it can be done quickly and become something useful and impactful.

Working on something driven by you will open your eyes very quickly. Building something from the beginning and solving real problems is aligned with the type of engineers that companies are looking for today—problem solvers who think outside the box and are goal-oriented.

All of this, especially if you are contributing to open-source projects, will be visible to your future potential employers and companies.

Cover all disciplines in the software development process

Even if you are fascinated by only one specific area, try to cover all directions in the development process. I am listing them below, but think of them as a whole. To align with what businesses expect today, software engineers must work as a complete team.

I know this seems like a lot. It is not necessary to become a guru in all of them from the beginning, but you should have basic knowledge of each. During a university degree (in computer science or informatics), you will go through most of them. If you are studying in an academy, probably only a few will be covered, so you need to actively fill the gaps.

Find good sources of content creators for software engineering

There are thousands of podcasts, authors, and content creators talking about software development. Find a few that work for you and follow their content weekly. It will help you stay informed about trends and technology direction.

Become a good engineer

It sounds broad, but especially at the beginning of your career, you should focus on the fundamentals of software engineering—good coding skills, understanding data, algorithms, software architecture, and other “boring” things. The better you become at these early on, the more opportunities you will have in the future. Use your university time to learn theory and apply it through experimentation in your pet projects, NGO work, or anywhere you can, to truly understand the abstractions you are using.

Use AI, Vibe Coding, and Context Engineering as primary instruments

You are in a great position—today’s AI tools allow you to do things that were impossible for entry-level engineers just a few years ago. AI is one of the main reasons for the current situation, but it is also the future of the industry. Choose the tools that work for you as AI coding assistants, use them heavily, improve the output, and understand it. This is how software will be developed in the near future.

Work on your personal network

This is an extra piece of advice, but maybe one of the most important. The way the world operates is based on human interactions and trust. The more people you know and who trust you, the greater your potential. You build connections through family, school, university, work, and all other interactions. The more touchpoints you have, the more people become part of your network. Start structuring this network early—keep useful information about people you meet: key skills, facts, and interests. Try to be helpful when possible and don’t fail them when you take responsibility. Over time, this network becomes one of your biggest assets—some of these people will become partners, sources of knowledge, investors, or coworkers.

Work on your CV

Start building your CV with both hard and soft skills, and include all projects you have participated in. Add live demos and public repositories. Include hobbies and achievements outside engineering (sports competitions, certificates, recognitions, etc.). Create a social media profile (LinkedIn is a good place), follow relevant groups and pages, and be active with comments and posts.

Some final words

This is not the fastest way to become a software engineer, but it is the right one. In recent years, there was a fast lane—learn some coding skills and enter the industry—but those times are over. If you want to build software, it is no longer a “code monkey” job, but an engineering one, and it takes time. If you enjoy it, then this is a great career path for you. If you enjoy it, all of the points above will come naturally—without stress, but with motivation and curiosity.

Good luck and enjoy! 🙂

Posted on
by

There is a growing narrative that “vibe coding” will eliminate the need for developers, that software engineering jobs are coming to an end, and that people in the industry should start thinking about new careers. While these claims are gaining attention, they oversimplify what is actually happening. In this article, I will share my perspective on what is truly changing, and what it means for the future of software development.

What is certain is that the way we build software is changing fundamentally.

When I started working as a software engineer about 22 years ago, it was neither particularly attractive nor highly paid. People were drawn to it not because of the money, but because of the possibilities—what could be created with a computer and an internet connection. Personally, I spent thousands of hours experimenting, testing, and building things that brought no financial return, simply because it was interesting, fun, or had the potential to improve something.

Over the past 15 years, this changed dramatically. The rapid growth of digitalization and the demand for new software products created an enormous need for engineers. Salaries increased significantly, and the industry attracted people from a wide range of backgrounds. At the same time, building software became more expensive year after year, while the overall efficiency of teams did not scale at the same pace.

Today, we are a few years into the widespread adoption of Large Language Models (LLMs), initially popularized by OpenAI, and we are seeing an explosion of tools across all areas of business. In this article, I will focus on software engineering, although the same shift is already visible in many other industries.

AI coding agents now enable even non-technical users to generate code and build entire applications. Tools like Lovable opened this space to a much broader audience. For the first time, people with ideas can describe what they want in plain language and receive working results almost instantly.
Of course, this approach does not yet scale easily to production-grade systems. But for building proofs of concept (POC) and MVPs, it is already extremely powerful. This was the first clear signal of how the industry could change, and since then, a wave of new tools and early frameworks for using AI at scale has started to emerge.

So here comes the question, how can we organize our work using that tooling so we could achieve high productivity, high quality and potential for future development and R&D of those systems.

Documentation becomes the control system

Documentation is no longer a byproduct of development.

It becomes the system that drives it.
Code is no longer the source of truth. Documentation is.

When AI is responsible for execution, the quality of the output depends entirely on the quality of the input. And that input is not code — it is structured documentation.

This is essentially Context Engineering (I liked the term immediately when heard), it represents exactly what the engineers need to do. Create the best context with documentation and prompts and execute it with the code agents.

Product requirements, technical specifications, architecture decisions, and prompt templates are no longer passive artifacts. They actively define how the system will be built.

In this model, documentation acts as a control layer:

  • It sets the boundaries
  • It provides context
  • It defines expected behavior

AI follows what is defined. Nothing more, nothing less.

This leads to a simple but critical rule:

Bad documentation leads to bad systems.
Well-structured documentation enables scalable, high-quality execution.

AI is the execution layer

AI should not be seen as the architect of the product, but as its execution layer.

That distinction is critical.

AI can generate code, refactor modules, write tests, prepare documentation, suggest architecture patterns, and accelerate delivery dramatically. But it does not own the business context, the priorities, the trade-offs, or the long-term vision of the system. Those remain human responsibilities.

This is why the role of the engineer is not disappearing — it is evolving.

Starting the project means providing the well-structured AI-oriented documentation, including functional definitions, technology information, default prompts, designs (also integrated with AI first design systems).

Engineers are no longer only implementers. They become orchestrators of the full development process: defining the structure, setting the constraints, providing the right context, validating outputs, and deciding what is good enough to move forward.

Development of the product should be staged on phases and every phase to be refactored and verified by the human engineers, refined and improved and created tests before continuing to the next phase of development.

In this model, AI provides speed. Humans provide direction.

When that balance is right, the result is not just faster development, but better development — more structured, better documented, more testable, and easier to improve over time.

QA by design

In traditional development, quality assurance often comes at the end of the process, unless you are using Test-Driven Development (TDD) approach of programming. Testing is treated as a final checkpoint before release. Here in the era of AI-DD it is part of the every phase of the development and it is crucial for verifying the quality and potential regression situations that may arise because of the speed of the development that we could achieve.

Because AI accelerates development significantly, it also increases the risk of introducing errors, inconsistencies, and regressions at a much faster rate. Without continuous validation, speed quickly turns into instability.

That’s why QA must be embedded into every phase of the development lifecycle.

Testing is not an afterthought — it is part of the system definition itself.

As part of the project documentation and AI instructions, teams should define:

  • Unit tests for core logic
  • Integration tests for system interactions
  • End-to-end tests for user flows
  • Edge-case scenarios for robustness

AI can assist in generating and maintaining these tests, but their structure and coverage must be intentionally designed by engineers.

In AI-DD, speed without QA is risk. QA is what makes speed sustainable.

Code is no longer written – it’s prompted

One of the most visible shifts in AI-Driven Development is how code is produced.

This does not mean coding disappears. It means coding becomes an outcome of a higher-level process.

Engineers describe:

  • what the system should do
  • how components should interact
  • what constraints must be respected

And AI translates that into working code.

The quality of the result depends not on typing speed, but on:

  • clarity of specifications
  • structure of prompts
  • completeness of context

Clear thinking leads to high-quality systems.

This is why prompting is not a shortcut — it is a new engineering skill.

Zero hand written code platforms are here! Having great documentation, organization of the project and guaranteed quality makes engineers to supervise the AI agents code generation only.

Final thoughts: What This Means for the Industry

AI-Driven Development will not eliminate software engineering — but it will fundamentally reshape it.

The most immediate impact is speed.
Teams can already build and iterate significantly faster — in some cases 5–10-20x, and in specific scenarios even more. This changes the economics of software.

Faster delivery means:

  • fewer people needed for the same output
  • shorter development cycles
  • more experimentation and iteration

As a result, parts of the market will compress.
Roles focused purely on execution will become less valuable, and compensation models will likely adjust over time.

But this is only one side of the shift.

The real transformation is in how engineers think and operate.

Engineers can no longer focus only on isolated tasks.
They need to understand the full system — product, architecture, infrastructure, integrations, testing, performance, security, and user experience — as a connected whole.

The role evolves from implementer to orchestrator.

From writing code → to defining systems
From executing tasks → to designing processes
From solving tickets → to owning outcomes

For those who embrace this shift, the opportunity is significant.

AI removes a large part of the mechanical work.
It allows engineers to focus on what actually matters: structure, decisions, and impact.

Those who enjoy technology, curiosity, and building systems will benefit the most.

Those who rely only on execution will struggle to adapt.

AI will not replace engineers.
But engineers who understand how to use AI will replace those who don’t.