Reflections on attention to detail, AI-assisted development, testing, self-imposed pressure, and becoming a more reliable software engineer.
TL;DR
Recently, I've been reflecting on some challenges I've faced in my software engineering workflow.
I've noticed that I sometimes misunderstand requirements, overlook important details, rely too heavily on AI-generated code and tests, and struggle to prioritize what actually matters.
Working with an unfamiliar technology stack and architecture has made these challenges even more noticeable.
Another important realization is that much of the pressure I experience is self-imposed. I sometimes push myself to deliver quickly, even when nobody is explicitly asking me to rush.
I've come to realize that the solution isn't necessarily to work harder, write code faster, or stop using AI.
Instead, I want to build a more deliberate engineering process focused on understanding, planning, implementation, validation, and communication.
I'm sharing these reflections, the lessons I've learned, and the changes I want to make to my workflow. I'd genuinely appreciate feedback from other developers and software engineers.
1. The Challenges I've Been Facing
For most of my career, I've worked primarily with JavaScript, frontend development, and its ecosystem.
Recently, I've been working in a different environment involving C#, MVVM, desktop applications, and a more complex enterprise architecture.
It's been an interesting transition, but it has also exposed weaknesses in how I approach software development.
The difficulty isn't necessarily learning a new programming language. It's understanding the architecture, existing conventions, state management, dependencies, and how changes can affect the rest of the system.
Here are the main challenges I've identified.
1.1. Misunderstanding requirements and dependencies
Sometimes I make assumptions about what needs to be done without fully validating my interpretation.
I've experienced situations where I misunderstood the expected order of activities or assumed that one task depended on completing another first.
These misunderstandings caused unnecessary delays.
Looking back, I realized that a few simple questions could have prevented much of that rework:
- What exactly is being requested?
- What is the expected outcome?
- Which steps are actual prerequisites?
- What assumptions am I making?
- What should I clarify before starting?
A few minutes spent confirming my understanding can save hours of unnecessary work.
1.2. Missing subtle but important details
This is probably one of my biggest challenges.
Sometimes I become so focused on solving the main technical problem that I overlook smaller requirements, edge cases, or existing behaviors that shouldn't change.
I also experience difficulties with attention and working memory, which can make it harder to keep track of several things simultaneously.
For example, a feature might work perfectly under normal conditions but fail when the user navigates away, changes application state, or resizes a window.
Individually, these details might seem small. In an existing production system, however, they can have significant consequences.
One thing I've realized is that attention to detail shouldn't depend entirely on my ability to remember everything.
I need a workflow that makes important details visible, trackable, and verifiable.
1.3. Writing tests without fully understanding what they prove
I've been using AI tools to help generate unit tests after implementing features.
Initially, my process was relatively straightforward:
- Implement the feature.
- Ask AI to generate tests.
- Run the tests.
- See them pass.
- Assume the functionality is sufficiently validated.
But I've learned that this approach can be misleading.
A test can pass without meaningfully validating the intended behavior.
For example, imagine testing a session timer.
A weak test might manually assign a display value, call a reset method, and verify that the displayed text becomes 00:00:00.
But that doesn't necessarily prove that the underlying session state was correctly reset.
A stronger test would start a real session, advance a controlled clock, manipulate the session through its public interface, and verify that the underlying state behaves correctly.
The difference is important.
Tests should validate requirements and observable behavior, not simply confirm that the implementation behaves like the implementation.
A question I want to ask more often is:
If I deliberately introduced the bug this test is supposed to catch, would the test fail?
If I can't confidently answer that, I probably need to reconsider the test.
1.4. Relying too heavily on AI-generated solutions
AI has become an important part of my development workflow.
I use it to understand unfamiliar concepts, explore possible solutions, generate code, and write tests.
However, I've noticed a potential weakness in how I use it.
Sometimes I rely on the same AI to:
- Interpret the requirements.
- Suggest an implementation.
- Generate the code.
- Generate the tests.
- Evaluate whether everything is correct.
This creates a potential feedback loop.
If the AI misunderstands a requirement, that misunderstanding can propagate through the code, tests, and final validation.
Everything might appear consistent while still being incomplete or incorrect.
The situation becomes even more challenging when the AI doesn't have access to the entire codebase or the project's architectural context.
I don't want AI to replace my engineering judgment. I want it to help me develop better engineering judgment.
1.5. Not documenting enough
I've been documenting changes in pull requests, but I've realized that sometimes important information is missing.
For example:
- Why a particular architectural decision was made.
- Which requirements were addressed.
- Which existing behaviors might be affected.
- What was actually tested.
- Which changes overlap with other tasks.
- What remains uncertain or intentionally outside the scope.
I want my pull requests to become more than summaries of modified files.
They should communicate the reasoning behind changes and provide enough context for someone else to understand, evaluate, and maintain the implementation.
1.6. Struggling with priorities and scope
Another challenge I've noticed is spending too much time on things that aren't necessarily the highest priority.
Sometimes I discover opportunities for refactoring or architectural improvements while working on a specific feature.
Those improvements may be valuable, but that doesn't automatically mean they belong in the current task.
I can end up investing time in something interesting while more important requirements still need attention.
I'm learning that being productive isn't just about doing useful things. It's about doing the right things at the right time.
2. The Pressure I Put on Myself
I think this is an important part of the conversation.
The pressure I experience doesn't necessarily come from my team, management, or external expectations.
Much of it comes from me.
I want to deliver quickly. I want to demonstrate that I'm capable. I want to contribute effectively, especially when working with technologies or architectures that aren't as familiar to me.
These motivations aren't inherently negative.
However, sometimes they lead me into a counterproductive cycle:
- I encounter something unfamiliar.
- I feel that I should be able to solve it quickly.
- I use AI to accelerate the implementation.
- I focus on getting the feature working.
- I move forward without fully understanding or validating everything.
- I discover issues later and spend additional time correcting them.
Ironically, trying to save time can create more work.
I've started questioning whether I'm sometimes confusing speed with progress.
Getting something working quickly can feel productive, but that doesn't necessarily mean I'm moving in the right direction.
Taking time to understand a problem isn't wasted time. It's part of solving it.
I want to become more comfortable with uncertainty and with the fact that understanding unfamiliar systems takes time.
I also want to recognize when I'm creating unnecessary urgency for myself.
My goal isn't to become slower. It's to become more deliberate and predictable.
3. Building a More Structured Engineering Workflow
To address these challenges, I want to adopt a more consistent approach to development.
I'm organizing it into six stages:
Understand → Investigate → Plan → Implement → Validate → Review
The purpose isn't to introduce unnecessary bureaucracy. It's to make sure I'm not skipping important steps simply because I'm focused on delivery.
Step 1: Understand
Before writing code, I want to create a short task brief containing:
- The problem being solved.
- The expected outcome.
- Original acceptance criteria.
- Known dependencies and constraints.
- Open questions and assumptions.
- Existing behaviors that must remain unchanged.
- A clear definition of done.
I also want to explain the task in my own words.
If I can't clearly explain what I'm supposed to accomplish, I probably need more context.
Step 2: Investigate
Before modifying code, I want to understand how the relevant parts of the system currently work.
Some questions I'll use:
- Where does the behavior originate?
- Who owns the state?
- Which components depend on it?
- What is the lifecycle of that state?
- Which existing architectural patterns should I follow?
- What could break if I introduce this change?
This is particularly important when working in unfamiliar codebases.
Instead of immediately asking AI to generate code, I want to investigate existing implementations and understand the reasoning behind them.
Step 3: Plan
Once I understand the problem, I want to identify the smallest reasonable solution.
I'll separate:
- Critical regressions and blockers.
- Required acceptance criteria.
- Necessary architectural improvements.
- Optional refactoring and future enhancements.
I also want to define meaningful test scenarios before implementation.
This should help me stay focused on the actual requirements and avoid unnecessary scope expansion.
Step 4: Implement
Rather than making many changes simultaneously, I want to work in smaller, focused increments.
For each increment:
- Make a targeted change.
- Understand why it's necessary.
- Verify that it builds.
- Check the expected behavior.
- Record relevant decisions.
The goal is to reduce uncertainty and make regressions easier to identify.
Step 5: Validate
This is probably the area where I want to improve the most.
Instead of simply asking whether the implementation works, I want to connect each acceptance criterion to concrete evidence.
For example:
| Requirement | Validation | Status |
|---|---|---|
| State survives navigation | Lifecycle test | Verified |
| Calculations handle edge cases | Unit tests | Verified |
| UI remains usable at smaller sizes | UI/manual test | Pending |
| Existing behavior remains unchanged | Regression tests | Pending |
I want to distinguish between something being implemented, tested, and actually verified.
These are not necessarily the same thing.
I also want to critically review AI-generated tests, especially when they depend heavily on implementation details or fail to exercise realistic scenarios.
A test passing doesn't automatically mean the requirement has been satisfied.
Step 6: Review and Document
Before submitting a pull request, I want to perform a deliberate final review.
My checklist will include:
- Are all acceptance criteria addressed?
- Did I verify the important existing behaviors?
- Are the tests meaningful?
- Did I introduce unnecessary complexity?
- Is there unused or unfinished code?
- Are there unrelated changes that should be separated?
- Can I explain every significant modification?
- Does the PR clearly document what was implemented and validated?
I also want to be transparent about anything I couldn't verify.
Unknown should mean unknown, not passed.
4. Rethinking How I Use AI
I don't intend to stop using AI for development.
Instead, I want to be more deliberate about the responsibilities I assign to it.
I'm thinking about three different roles.
AI as a tutor
Help me understand unfamiliar concepts, architectural patterns, and technical decisions.
Explain why something works, what alternatives exist, and how different parts of the system interact.
I sometimes use Socratic questioning for this, but I've also noticed that it can become unnecessarily time-consuming.
I want to use it when it adds value rather than turning every technical question into a long learning session.
AI as an implementation assistant
Help me explore solutions and implement focused changes once I understand the requirements and relevant architecture.
I want to avoid accepting large amounts of generated code that I can't fully explain.
AI as a critical reviewer
Challenge my assumptions and look for missing requirements, weak tests, regressions, and unnecessary complexity.
Instead of simply asking:
Is my code correct?
I'd rather ask:
Assume this implementation contains subtle bugs. What could be missing? What might break? Which tests aren't proving enough? What evidence would you need before trusting this change?
I think this approach can make AI significantly more useful.
But ultimately, AI-assisted development still requires independent reasoning, access to the actual project context, real validation, and human review.
5. Improving Focus, Organization, and Prioritization
I'm also working on improving how I manage my attention and organize my work.
Instead of trying to remember every requirement, decision, and next step, I want to externalize important information.
This means developing habits such as:
- Taking short, structured notes during meetings and investigations.
- Recording decisions, action items, and unresolved questions.
- Maintaining a single checklist for requirements and review feedback.
- Breaking larger tasks into smaller, verifiable steps.
- Reducing unnecessary context switching.
- Setting aside dedicated time for validation.
- Asking for clarification when an important assumption remains unresolved.
- Ending work sessions with a clear next action.
I also want to become more deliberate about prioritization.
Not every improvement I identify needs to be implemented immediately.
I want to consistently distinguish between what is required, what is necessary for reliability, and what can be addressed separately.
And when I'm uncertain about an architectural decision, I'd rather seek feedback early than spend hours implementing something based on an incorrect assumption.
The idea is to build a workflow that remains reliable even when my attention isn't perfect.
6. What I'm Committing to Improving
I don't want to turn this reflection into a rigid schedule or set arbitrary deadlines for personal growth.
Instead, I want to establish a set of engineering habits that I can practice consistently and improve over time.
Understanding before implementing
I want to stop treating uncertainty as something I should immediately overcome by writing code.
I'll take more time to clarify requirements, identify assumptions, and understand existing implementations before introducing changes.
Keeping requirements visible
I'll maintain a clear connection between the original acceptance criteria, the implementation, and the validation evidence.
I don't want requirements to disappear during refactoring or get lost among code review comments.
Writing more meaningful tests
I'll focus on testing actual behavior, state transitions, edge cases, and regressions.
I'll also challenge AI-generated tests instead of assuming they're sufficient simply because they pass.
Reviewing my own work more critically
I'll make deliberate pre-PR reviews part of my workflow.
That means checking the diff, looking for unrelated changes, identifying unused code, reviewing bindings and dependencies, and considering what could break.
Documenting decisions more clearly
I'll work on making my pull requests easier to understand by explaining what changed, why it changed, how it was validated, and what remains outside the scope.
Managing scope and priorities better
I'll focus on completing the actual requirements before pursuing optional improvements.
When I identify unrelated technical debt, I'll record it instead of automatically expanding the current task.
Using AI without outsourcing my understanding
I'll continue using AI to learn, investigate, implement, and review.
But I want to remain responsible for understanding the problem, evaluating the solution, and verifying the outcome.
Communicating uncertainty earlier
I'll become more intentional about asking questions and seeking feedback when something isn't clear.
I don't want to confuse asking for clarification with a lack of independence.
Sometimes, asking the right question is the most effective engineering decision.
Managing my own expectations
Finally, I want to work on recognizing when I'm creating unnecessary pressure for myself.
I want to value understanding, reliability, and meaningful progress rather than measuring my performance primarily by how quickly I deliver something.
These are ongoing commitments, not boxes I expect to check once and forget.
The goal is continuous improvement, not a perfect workflow.
7. Learning to Think More Like a Software Engineer
One of my broader goals is to improve how I approach engineering decisions.
I've been reflecting on what separates writing code from engineering reliable systems.
I don't think the answer is simply knowing more languages, writing code faster, or applying more sophisticated patterns.
Increasingly, I think it's about asking better questions:
- What problem are we actually solving?
- What assumptions are we making?
- What could go wrong?
- What behavior must remain unchanged?
- How can we prove the solution works?
- Is this complexity necessary?
- How will someone else understand and maintain this implementation?
- What risks and limitations should be communicated?
I'm learning that engineering maturity isn't necessarily about having all the answers.
It's about becoming better at recognizing what you don't know, gathering the right information, making informed decisions, and validating the results.
I want to move from "I made it work" to "I understand why it works, what could break, and how I verified it."
8. What I've Learned So Far
If I had to summarize my biggest lessons, they would be:
1. Understanding comes before implementation.
Writing code quickly doesn't help if I'm solving the wrong problem.
2. Passing tests aren't enough.
Tests need to validate meaningful behavior and provide confidence in the requirements.
3. AI is an assistant, not an authority.
Its suggestions still require context, judgment, and independent verification.
4. Attention to detail needs a system.
Checklists, written requirements, and verification steps can reduce dependence on memory.
5. Prioritization is part of engineering.
Not every improvement is necessary for the current delivery.
6. Communication can prevent unnecessary rework.
Clarifying uncertainty early is often more efficient than making assumptions.
7. Self-imposed pressure can affect quality.
Moving quickly isn't always the same as making meaningful progress.
8. Engineering is about more than code.
Architecture, testing, trade-offs, documentation, and understanding existing behavior all matter.
Final Thoughts
I know that becoming a better software engineer isn't something that happens simply by adopting a checklist, following a workflow, or finding better AI prompts.
It takes practice, feedback, reflection, and continuous improvement.
I'm still learning how to navigate unfamiliar architectures, make better technical decisions, and develop greater confidence in my own reasoning.
I don't expect to eliminate mistakes completely.
But I want to build better habits for preventing them, identifying them earlier, and learning from them.
Most importantly, I want to shift my focus from proving that I can solve problems quickly to becoming someone who approaches them thoughtfully and delivers reliable, maintainable solutions.
My goal isn't to become an engineer who never makes mistakes. It's to become an engineer whose work is easier to understand, easier to verify, and easier to trust.
I'd Love Your Feedback
I'm sharing this because I believe these challenges are worth discussing, especially as AI becomes more integrated into software development.
I'd love to hear how other developers and software engineers approach these situations:
- How do you ensure you've fully understood a task before implementing it?
- How do you prevent subtle requirements or edge cases from being overlooked?
- How do you evaluate whether your tests are actually meaningful?
- How do you use AI without becoming overly dependent on it?
- How do you manage self-imposed pressure to deliver quickly?
- What habits have helped you develop better engineering judgment?
I'd genuinely appreciate any experiences, suggestions, or constructive feedback.
I'm not looking for a perfect workflow. I'm trying to build a better one, one iteration at a time.
Top comments (1)
One practice I'd add is to separate the source of truth from the implementation and its validation. Keep acceptance criteria and expected behavior independent of the AI-generated code, then use them to review both the implementation and the tests. Otherwise, the same misunderstanding can flow from requirements into code, then into tests that simply confirm the original assumption.
At IT Path Solutions, this is an important part of stabilizing AI-assisted development. I'd also recommend testing state transitions and failure paths through public interfaces, rather than relying mainly on assertions about internal implementation details. A useful question is: if the implementation were wrong in a realistic way, would this test actually catch it?
The shift from "it works" to "I can prove it works" is really about making engineering decisions traceable to evidence. And I like the point about not treating uncertainty as a personal failure. Clarifying an assumption early is often much cheaper than debugging a confident assumption later.