This semester really changed the way I look at software. At first, I thought it was mainly about writing code that works and figuring out how to build a website. But as the class went on, I realized that software engineering is about so much more than just the technical side. It’s about how people work together, how projects are organized and improved over time, and how the choices we make as developers affect the real people who use what we build.
Yes, we created a web app—but the most important lessons came from the process, not just the final product. I learned how to take big ideas and break them down into manageable tasks, how to write code that others can actually follow, and how to design things with real users in mind. I also learned that being a good developer means thinking beyond the code—it’s about building things responsibly, and with purpose. In this reflection, I want to share four key lessons I’ll take with me from this class: Agile Project Management, Open Source Collaboration, User Interface Frameworks, and Ethics in Software Engineering. These are things I’ll keep using, no matter what kind of project I’m working on next.
Agile Project Management focuses on being flexible and improving as you go, instead of trying to follow a fixed plan from start to finish. In class, we used a specific style called Issue Driven Project Management (IDPM). Every feature, task, or bug we had to deal with became a GitHub issue, and each one had to be linked to a commit and pull request. That structure kept us organized and helped our team stay on the same page.
What I liked most about Agile was how realistic it felt. Things don’t always go as planned, and Agile gave us room to adapt when something took longer or needed to change. I can totally see myself using this system outside of software, too—like planning group projects, events, or anything that requires team coordination. Breaking down work into clear tasks, assigning them, and checking things off feels way more manageable than trying to tackle everything at once. It helped reduce stress and made progress easier to see.
Another thing I appreciated about Agile is how it encouraged us to check in frequently and adjust our goals as needed. We didn’t have to get everything perfect the first time—instead, we focused on making progress in small steps, then refining based on feedback. This helped reduce pressure and made the team feel more collaborative. In future group projects or internships, I’d want to keep that same energy—communicating often, staying flexible, and making sure the team feels supported and in sync.
Before this class, I used to think “open source” just meant free code you could find online. But now I understand that Open Source Software Development is really about collaboration, transparency, and creating something together. We used GitHub throughout the semester, which gave me experience with things like pull requests, forking, and reviewing code. It wasn’t just about writing your own piece—it was about making sure your work fit with everyone else’s and could be understood by others later.
One of the biggest mindset shifts for me was realizing that good code isn’t just about making it work—it’s about making it readable, clear, and easy to build on. I started caring more about how I named things, how I left comments, and how I organized files. These habits are useful in more than just programming. Whether I’m working on shared documents, slides, or team spreadsheets, I now think more about how someone else might interact with my work. Open source really taught me to think like a teammate, not just an individual contributor.
Contributing to a shared codebase also helped me think about long-term maintenance. I started asking myself, “If someone else looks at this six months from now, will it still make sense?” That shift really changed the way I structured my code. It made me want to write in a way that was not only functional, but also kind to the next person who might have to read or edit it. I feel like that’s a core part of software engineering—building things that are meant to last and evolve.
User Interface (UI) Frameworks helped me see how design and structure can come together to make something not just functional, but easy to use. In class, we used tools like Bootstrap, React, and sometimes Tailwind CSS to build consistent layouts and components. These frameworks saved a lot of time since we didn’t have to start from scratch every time—and the result always looked more polished than if I tried to design everything on my own.
What made this lesson stick with me was how much it changed the way I thought about users. I found myself asking questions like: Would this make sense to someone seeing it for the first time? Is the layout confusing? Would a user know where to click next? That kind of thinking makes a huge difference. It’s not just about making something look nice—it’s about guiding the user through an experience that feels simple and smooth. That mindset is something I’ll definitely take with me, even if I’m working on something totally different like a mobile app, a form, or even a presentation.
Using UI frameworks also helped me understand how design systems work. For example, using Bootstrap’s grid system gave me a better sense of spacing, alignment, and responsive design. I started noticing the patterns in professional sites and realized how much planning goes into even small layout decisions. Learning how to work with these systems taught me how to move fast without sacrificing structure—and gave me a better eye for visual balance and consistency.
One of the most unexpected and important parts of this class was learning about ethics in software development. We talked about how developers have a responsibility to think about how their work affects others. That includes protecting user data, being inclusive and accessible, and making sure what we build is fair and responsible. It’s easy to forget that the software we write can have real consequences, but this class brought that idea to the front.
We also talked about using tools like ChatGPT to help with coding. I used it a few times this semester to get past blocks or debug something, but I learned quickly that you can’t just trust the answer and move on. You still have to understand the code and double-check that it actually fits your project. That idea—that we’re responsible for the code we write, no matter where it comes from—really stuck with me. Going forward, I want to keep that same mindset whenever I’m working on something that could impact other people.
We also explored ethical challenges like algorithmic bias, especially in systems that make decisions about people—like loan approvals or hiring tools. It was eye-opening to see how even small mistakes in code or data can have a huge impact. That made me want to be more careful and intentional with my own work. I don’t want to just assume that code is “neutral”—I want to be aware of how my choices might help or harm people, and how to design more fairly from the start.
Even though this class was centered around web development, the lessons I’m taking with me go far beyond that. I’ve learned how to manage projects more effectively, communicate clearly in a team, think from the user’s perspective, and consider the bigger picture when building something. These aren’t just technical skills—they’re part of a software engineering mindset that I know I’ll use again and again.
Whether I’m working on a tech project, leading a group assignment, or even organizing something for a student club, I know the habits I’ve built in this class will help me stay organized, thoughtful, and focused on the people I’m building for. More than anything, this class helped me feel like a real software engineer—not just because I can code, but because I’ve learned how to plan, collaborate, and build responsibly.
This course didn’t just teach me technical tools—it taught me how to think more strategically and work with others in a way that felt organized and respectful. I’ve become more confident asking questions, explaining my ideas, and helping others debug. These are small things, but they’ve helped me grow both as a student and as someone preparing to work in tech. I’m excited to keep building on these skills and continue learning in future projects and classes.
This essay was reviewed using AI (ChatGPT) for grammar checking and readability improvements.