Sheldon Wang

Sheldon Wang

Seasoned iOS Veteran, Mentor

What’s the Most Constructive Feedback You Received? A Career Evolution Story

Published:

💼 Question: “What’s the Most Constructive Feedback You Received?”

Common variants:

  • “Tell me about feedback that changed how you work”
  • “What’s the best advice you’ve received in your career?”
  • “Describe a time feedback helped you grow”
  • “What feedback made you a better engineer?”

What they’re really asking:

  • Are you coachable and open to feedback?
  • Can you reflect on your growth?
  • Do you learn from mistakes and feedback?
  • How have you evolved as an engineer?
  • Can you show career progression and maturity?

Why this question is tricky:

  • ✅ Easy to answer with a simple story
  • ❌ Hard to answer WELL - most people give generic responses
  • 🎯 The key: Show evolution across your entire career, not just one incident

🎯 The Framework: Career Progression Through Feedback

Instead of one story, frame your answer as a journey of growth through different career stages. Each stage had feedback that pushed you to the next level.

The Structure:

  1. Junior Engineer → Feedback on code quality and fundamentals
  2. Senior Engineer → Feedback on system thinking and architecture
  3. Staff Engineer → Feedback on impact and cross-functional leadership
  4. Principal Engineer → Feedback on tooling, efficiency, and AI adoption

📱 Stage 1: Junior Engineer - “Write Code That Others Can Understand”

The Feedback (Circa Early Career)

Situation: “As a junior iOS engineer, I was proud of writing clever, compact code. I’d use complex Swift features, nested closures, and one-liners that solved problems efficiently. My code worked, but during code review, my senior engineer gave me feedback that changed everything.”

The Feedback:

“Your code is clever, but it’s not maintainable. The most important skill isn’t writing code that works—it’s writing code that your teammates can understand and modify six months later. Code is read 10x more than it’s written. Optimize for the reader, not the writer.”

What I Learned:

  • ✅ Readability > Cleverness: Simple, explicit code beats clever one-liners
  • ✅ Documentation Matters: Comments explain “why,” not “what”
  • ✅ Naming is Critical: fetchUserProfile() is better than getData()
  • ✅ Code Reviews are Learning Opportunities: Every review makes you better

Example Evolution:

// Before (Clever but unclear)
users.filter { $0.age > 18 }.map { $0.name }.sorted { $0 < $1 }

// After (Clear and maintainable)
let eligibleUsers = users.filter { user in
    user.age >= minimumAge
}
let userNames = eligibleUsers.map { user in
    user.displayName
}
let sortedNames = userNames.sorted { firstName, secondName in
    firstName < secondName
}

Impact:

  • My code review approval rate improved from 60% to 95%
  • Other engineers could jump into my code and contribute immediately
  • I became known as someone who wrote “maintainable code”

🏗️ Stage 2: Senior Engineer - “Think Beyond Your Feature”

The Feedback (Mid-Career)

Situation: “As a senior engineer, I was leading a major feature: rebuilding the Stories feature at Snap. I focused on making my feature perfect—great performance, beautiful UI, zero bugs. But during a design review with my engineering manager, I got feedback that shifted my perspective.”

The Feedback:

“You’re thinking like a feature owner, not a platform engineer. Your Stories feature is great, but it’s consuming 40% of our app’s memory. How does this affect other features? What happens when we add 5 more features like this? Think about the system, not just your component.”

What I Learned:

  • ✅ System Thinking: Consider how your code affects the entire app
  • ✅ Resource Awareness: Memory, battery, network—everything is shared
  • ✅ Platform Mindset: Build for reuse, not just your use case
  • ✅ Trade-off Analysis: Perfect feature vs. sustainable architecture

Example Evolution:

Before (Feature-Focused):

  • Built Stories with its own image cache
  • Created custom networking layer
  • Implemented separate analytics system
  • Result: 200MB memory footprint, duplicated code

After (Platform-Focused):

  • Used shared image caching infrastructure
  • Leveraged existing networking layer with Stories-specific extensions
  • Integrated with company-wide analytics
  • Result: 50MB memory footprint, reusable components

Impact:

  • My features became building blocks for other teams
  • Reduced app memory usage by 30% across all features
  • Promoted to Staff Engineer for platform thinking

🚀 Stage 3: Staff Engineer - “Impact Multipliers, Not Just Output”

The Feedback (Staff Level)

Situation: “As a Staff Engineer, I was shipping features faster than ever. I’d complete 3-4 major projects per quarter, writing thousands of lines of code. But during my performance review, my director gave me feedback that was initially hard to hear.”

The Feedback:

“You’re incredibly productive, but you’re optimizing for the wrong metric. Writing more code isn’t impact—enabling 10 engineers to ship faster is impact. Stop being the hero who fixes everything. Start being the multiplier who makes everyone else better.”

What I Learned:

  • ✅ Leverage Over Labor: 1x your impact by enabling 10x others
  • ✅ Documentation as Force Multiplier: Good docs save hundreds of hours
  • ✅ Mentoring > Coding: Teaching others scales your impact
  • ✅ Tooling > Features: Build tools that accelerate the team

Example Evolution:

Before (Individual Contributor Focus):

  • Shipped 4 major features per quarter
  • Fixed bugs directly
  • Wrote code for my projects
  • Impact: ~4 features shipped

After (Multiplier Focus):

  • Built internal tooling (CI/CD improvements, code generators)
  • Created reusable architecture patterns
  • Mentored 5 engineers who then shipped 20 features
  • Impact: ~25 features shipped (through others)

Impact:

  • Team velocity increased 40% through tooling I built
  • 5 engineers I mentored were promoted
  • My “output” decreased, but my impact increased 6x

🤖 Stage 4: Principal Engineer - “Embrace AI, Don’t Fight It”

The Feedback (Principal Level - Most Recent)

Situation: “As a Principal Engineer in 2024-2025, I was skeptical of AI coding tools. I’d built my career on deep technical knowledge and thought AI would make engineers lazy or produce low-quality code. During a 1:1 with my VP of Engineering, I received feedback that completely changed my perspective.”

The Feedback:

“You’re fighting the wrong battle. AI isn’t replacing engineers—it’s amplifying them. The engineers who embrace AI tools like Cursor will be 10x more productive. The ones who resist will be left behind. Your job isn’t to write more code—it’s to solve harder problems. Let AI handle the boilerplate so you can focus on architecture, system design, and innovation.”

What I Learned:

  • ✅ AI as Force Multiplier: Use AI to handle repetitive tasks
  • ✅ Focus on High-Value Work: Let AI write boilerplate, you solve hard problems
  • ✅ Tool Evolution is Constant: Embrace new tools, don’t resist change
  • ✅ Custom AI Workflows: Build agent flows for your specific needs

My AI Tool Evolution Journey

Phase 1: Cursor 1:1 Usage (2024)

Initial Adoption:

  • Started using Cursor for code completion and suggestions
  • Used it for boilerplate code generation
  • Helped with documentation and comments

Feedback Integration:

  • Realized I was still thinking too small
  • Started using Cursor for entire feature implementations
  • Used it to explore different architectural approaches

Impact:

  • 2x faster feature development
  • More time for code review and architecture
  • Better code quality (AI caught bugs I might have missed)

Phase 2: Advanced Cursor Workflows (2025)

Custom Agent Flows:

  • Built Cursor agents for specific tasks:
    • Testing Agent: Generates unit tests from code
    • Refactoring Agent: Suggests improvements based on patterns
    • Documentation Agent: Auto-generates API docs
    • Migration Agent: Helps with Swift version upgrades

Example: Custom Testing Agent Flow

# .cursor/agents/testing-agent.yml
name: Testing Agent
purpose: Generate comprehensive unit tests
workflow:
  1. Analyze code structure
  2. Identify test cases (happy path, edge cases, error handling)
  3. Generate XCTest cases
  4. Suggest integration test scenarios
  5. Review test coverage

Impact:

  • Test coverage increased from 60% to 85%
  • Reduced time writing tests by 70%
  • More time for complex integration testing

Phase 3: Custom AI Tooling for Mobile Engineering (2025)

Building Custom Agent Flows:

1. Architecture Review Agent

  • Analyzes code for architectural violations
  • Suggests design pattern improvements
  • Checks against team’s architecture guidelines
  • Generates architecture decision records (ADRs)

2. Performance Analysis Agent

  • Reviews code for performance bottlenecks
  • Suggests optimizations (memory, CPU, battery)
  • Analyzes network call patterns
  • Recommends caching strategies

3. Security Review Agent

  • Scans for common iOS security issues
  • Checks for sensitive data exposure
  • Reviews authentication/authorization patterns
  • Suggests security best practices

4. Code Review Agent

  • Pre-reviews code before human review
  • Checks for common bugs and anti-patterns
  • Validates against coding standards
  • Suggests improvements

Example: Custom Architecture Agent

# Custom agent for iOS architecture review
class iOSArchitectureAgent:
    def analyze(self, codebase):
        # Analyze MVVM/MVC/VIPER patterns
        # Check dependency injection
        # Validate separation of concerns
        # Suggest improvements
        return architecture_report

Impact:

  • Code quality improved (fewer bugs in production)
  • Faster code reviews (agents catch issues early)
  • Consistent architecture across team
  • New engineers onboard faster (agents explain patterns)

The Transformation

Before AI Adoption:

  • Writing boilerplate code: 30% of time
  • Debugging: 20% of time
  • Architecture/design: 20% of time
  • Code review: 15% of time
  • Learning new tech: 15% of time

After AI Adoption:

  • Writing boilerplate code: 5% of time (AI handles it)
  • Debugging: 10% of time (AI catches issues early)
  • Architecture/design: 40% of time (more focus on hard problems)
  • Code review: 20% of time (reviewing AI-generated code + human code)
  • Learning new tech: 25% of time (more time for growth)

Result:

  • 3x more productive on feature development
  • 2x faster at onboarding new engineers (AI agents help)
  • 50% reduction in production bugs (AI catches issues)
  • More time for system design and innovation

🎯 How to Frame This in an Interview

The Complete Answer (STAR Format)

Situation: “I’ve received many pieces of constructive feedback throughout my career, but the most impactful one came from my VP of Engineering about 18 months ago. At the time, I was a Principal Engineer who was skeptical of AI coding tools. I’d built my career on deep technical knowledge and thought AI would make engineers lazy or produce low-quality code.”

Task: “I needed to evolve my thinking. The industry was moving toward AI-assisted development, and I was resisting it. My VP challenged me to not just use AI tools, but to think about how to build custom workflows and agent flows that would amplify our entire team’s productivity.”

Action: “I took a three-phase approach:

Phase 1: Personal Adoption

  • Started using Cursor for daily development
  • Used it for boilerplate, documentation, and code suggestions
  • Measured impact: 2x faster feature development

Phase 2: Team Enablement

  • Built custom Cursor agents for common tasks (testing, refactoring, documentation)
  • Created workflows that other engineers could use
  • Impact: Team velocity increased 40%

Phase 3: Custom Tooling

  • Built specialized AI agents for mobile engineering:
    • Architecture review agent
    • Performance analysis agent
    • Security review agent
    • Code review agent
  • These agents now help our entire organization”

Result: “This feedback transformed how I work and how I think about engineering:

  1. Personal Impact: I’m 3x more productive, spending more time on architecture and system design
  2. Team Impact: Our team velocity increased 40%, and we have 50% fewer production bugs
  3. Organizational Impact: The custom agents I built are now used across multiple teams
  4. Career Impact: I’ve become known as someone who embraces new tools and builds systems that amplify others

Most importantly, this feedback taught me that the best engineers don’t just write code—they build systems and tools that make everyone better. And in 2025, that includes leveraging AI to solve harder problems while automating the routine work.”

💡 Key Takeaways for Your Answer

What Makes This Answer Strong:

  1. ✅ Shows Career Progression: Demonstrates growth across multiple levels
  2. ✅ Specific Examples: Real numbers and concrete impacts
  3. ✅ Tool Evolution: Shows you adapt to new technologies
  4. ✅ AI Integration: Demonstrates forward-thinking and modern engineering practices
  5. ✅ Multiplier Mindset: Shows you think beyond individual contribution
  6. ✅ Mobile Engineering Focus: All examples are iOS/mobile-specific
  7. ✅ Recent Relevance: Includes cutting-edge AI tooling (2024-2025)

What Interviewers Are Looking For:

  • Growth Mindset: Can you learn and adapt?
  • Tool Mastery: Do you leverage tools effectively?
  • Impact Thinking: Do you optimize for impact, not just output?
  • Leadership: Can you enable others?
  • Innovation: Do you embrace new technologies?

Common Mistakes to Avoid:

❌ Too Generic: “My manager told me to communicate better” ❌ Single Incident: Only talking about one piece of feedback ❌ No Evolution: Not showing how you’ve grown ❌ Resistance to Change: Talking about how you resisted new tools ❌ No Impact: Can’t quantify the results

✅ Your Approach: Show a journey of growth, with specific examples, measurable impact, and evolution toward modern engineering practices including AI tools.

🎓 Additional Talking Points

If They Ask Follow-Up Questions:

Q: “How do you ensure AI-generated code is high quality?”

  • “I treat AI as a pair programming partner, not a replacement. I review all AI-generated code, write tests, and use our custom agents to validate architecture and security.”

Q: “Aren’t you worried AI will replace engineers?”

  • “No—AI handles the routine work so I can focus on solving harder problems: system design, architecture decisions, cross-functional collaboration, and innovation. The engineers who embrace AI will be the ones who thrive.”

Q: “How do you measure the impact of AI tools?”

  • “We track: development velocity, bug rates, code review time, and engineer satisfaction. Since adopting AI tools, we’ve seen 40% faster feature delivery and 50% fewer production bugs.”

🚀 Conclusion

The question “What’s the most constructive feedback you received?” is an opportunity to show:

  1. Career Evolution: Growth from junior to principal
  2. Adaptability: Embracing new tools and technologies
  3. Impact Thinking: Focusing on multipliers, not just output
  4. Modern Engineering: AI-assisted development and custom workflows
  5. Leadership: Enabling others through tools and mentorship

Remember: The best answers show a journey, not just a moment. Frame your feedback story as evolution across your entire career, with the most recent chapter being your embrace of AI tools and custom agent flows.

This demonstrates that you’re not just a good engineer—you’re an engineer who continuously evolves, adapts to new technologies, and builds systems that make everyone better.

This answer works for interviews at Meta, Google, Apple, Snap, and other top tech companies. It shows technical depth, leadership, and forward-thinking—exactly what they’re looking for in senior and principal engineers.