End of year, end of the course, so it's time to do a proper update on the three skills I've been tracking.

Focussing

This has genuinely improved. At the start of the year I was writing about Pomodoro like it was some kind of solution — honestly I'd already been using it for ages, it wasn't new. The real issue was never concentration in general, it's that I can't focus on things I don't find interesting. On the group project I could sit and work for hours without thinking about it. On documents like this one, no technique in the world helps. I think that's just how it is and I've stopped pretending otherwise. What actually changed is that I got better at structuring the work I do care about — knowing when I work best and saving the harder technical problems for those windows.

Integrity

This is the one I feel most solid on now. The group project pushed it in ways that individual work doesn't, because when you're building something that four people depend on you actually have to understand what you're doing. There were moments with the Cal.com integration where there was almost nothing useful online for my specific setup, so I had to piece it together from the docs and figure out each part myself. Same with AI — I used it throughout the project but mostly as a starting point or a way to think through a problem, not as something to copy from. When a suggestion didn't fit how I'd built things, I had to catch that, and catching it required actually understanding the code. That's become more of a habit now than something I have to consciously remind myself to do.

Collaborating

Still the hardest one and I'm not going to pretend otherwise. I still prefer working alone. But I did get better at it during the group project, partly because I didn't have a choice. I was responsible for the front end and the API, which meant everything connected through me — I had to talk to Dawid about how the database responses should look before I could write the front-end code, and I had to integrate Vlada F.'s Strapi setup into my Vue components. That kind of dependency forces communication whether you want it or not. I also ended up taking on things that weren't my job, like meeting agendas, when they weren't getting done. In hindsight that's probably me reverting to just doing it myself rather than properly collaborating, but at least the communication around it was better than it would have been a year ago.

Overall the year went fine. Choosing three specific skills was the right call — I can actually point to real examples of each one instead of just writing vague things about "growth". Whether the scores on a table reflect any of that is another question.

We've been working on a group project for a while now and this feels like the right time to write about Collaborating properly.

It's been fine but it hasn't been easy. I said back in September that I prefer working alone and that's still true. When I'm on my own I can organise things exactly the way I want and work at my own pace. In a group you can't do that, and adjusting to that has been the main challenge.

What I've been trying to do differently is actually ask before assuming. My natural instinct when something isn't done or isn't done the way I'd do it is to just sort it myself. But that's not really collaborating, that's just working around people. So I've been making more of an effort to check in, communicate what I'm doing, and give people space to do their part.

Git has also been something I've had to get more comfortable with in a group context. Using it properly when multiple people are working on the same thing is different from using it solo. I've made a few mistakes but I've learned from them.

Overall, it's still my weakest area but I can feel it improving. The project is going well and I think that's partly because the communication in the group has been decent.

End of semester. Good time to check in on how things are going with the three skills.

Focussing — better, but not where I want it to be. I've got better at structuring my sessions and I can concentrate for longer than I could in September. The Pomodoro method helps when I actually use it. The honest issue is consistency. Some weeks I'm really disciplined and some weeks I'm not. I think that's just how it goes but I'd like to be more consistent in the second semester.

Integrity — this one has actually felt natural. I think because the projects this semester pushed me to really understand what I was doing rather than just getting something to work. There were moments where I found a solution online and had to stop myself from just copy-pasting it. Taking the extra time to understand it properly made a difference when it came to explaining or adapting it later. I feel more confident here than when I started.

Collaborating — I've done a bit of group work and it's been fine so far. Nothing major yet but I can already tell that my instinct is to just take over and do things myself rather than properly collaborate. That's something I'm going to have to watch in the second semester when the bigger group project starts.

So it's been a few weeks into the new year and I wanted to write something down while it's still fresh.

Focussing has been... mixed, honestly. The work is more complex than last year — there's a lot more going on at once and I can feel the difference. I've been trying the Pomodoro thing properly and it does help, but only if I actually commit to it. The problem is I don't always do that. Some days I'll sit down to work and two hours later I've done about 40 minutes of actual coding. I know what the issue is, I just haven't fully fixed it yet.

Integrity-wise, I think I'm doing better than I expected. I use AI and online resources a lot — that's just how it works now — but I've been more careful about how I use them. One thing that's actually helped is using AI to learn rather than just to get answers. I'll ask it to explain something like I'm a beginner, or to help me prepare for a test by quizzing me on a topic. That way I actually understand the material instead of just getting a working solution I don't really get. It takes longer but I feel more confident when I can explain what the code is doing and why. That feels like progress.

Collaborating hasn't really been tested yet. Most of the work so far has been individual. I know that's coming though, so I'm trying not to think about it too much.

Right, it’s another year at Nescol, which means another round of tracking our meta-skills for the HND. It’s a required part of the course, so I've got to lay out what I'll be working on.

After doing this last year for the HNC, I've got a better idea of how it works. My plan for last year was a bit all over the place, trying to improve too many things at once. This year, for the software development course, I’m just going to narrow it down to three specific skills that I know will come up in our projects.

1. Focussing (Self-Management)

I had this on my list last year, and it’s staying. Why? Because it’s one thing to focus when you’re learning basic HTML, but it's a completely different challenge when you’re deep in a complex database problem or debugging a tricky application. Distractions are the enemy of good code. My plan is to continue using techniques like the Pomodoro method, but also to get better at structuring my coding sessions so I can maintain that deep concentration for longer. This is all about building professional stamina.

2. Collaborating (Social Intelligence)

Most of our bigger projects are going to be group work, so I need to be better at this. It's not just about doing my assigned tasks. I need to get more comfortable using tools like Git properly, giving useful feedback on other people’s code, and making sure my work actually integrates with what everyone else is doing.

3. Integrity (Self-Management)

Let's be clear, this isn't about never looking for answers online – every developer does. The point is to not copy code blindly. For me, integrity means taking the time to understand how a solution works and why it solves the problem before adapting it for my own project. I should be able to explain every single line of code I write. This way of thinking also applies to using AI. You can and should use it, but the goal isn't the speed of writing lines of code; it’s about understanding the process behind it.

So, that’s the focus for this year. This blog is where I’ll be keeping a record of how I’m getting on with these three skills. We'll see how it goes.