Recently, we added a new developer to our team who had never programmed before (ok, he is not a full-time developer. He just wanted to put out a feature!).
Teaching someone to code while building production features presents unique challenges, but the results were surprisingly impressive. Here's how we built a share feature in just 4 hours total, and what we learned about platform-specific development constraints.
The Project: Implementing Share Functionality
Our new developer took on implementing a share feature for our clipboard extension. Despite being completely new to programming, he was able to deliver a working solution in record time.
Development Timeline:
- New developer time: 3 hours
- My time to close everything up: 1 hour
- Total project time: 4 hours
- Estimated solo time: 1.5 hours for experienced developer
Although that looks like the new developer was slow, realize that this also coincided with him having to install all the normal stuff that the techbros normally have. Everything from Homebrew, NPM, and Git all had to be installed! And also learned from scratch, as he had little to no experience in any of those domains.
Cross-Platform Sharing Challenges
The most significant hurdle wasn't the coding itself, but understanding platform-specific sharing restrictions:
Windows vs. Apple Sharing Policies
Windows Approach:
- Simple URL sharing
- Minimal restrictions
- Direct implementation works perfectly
- Maximum developer flexibility
Apple's Restrictive Approach:
- Requires source URL specification
- Mandatory title standardization
- Strict control over sharing format
- Limited customization options
Apple's sharing API demands specific metadata that Windows doesn't require, creating cross-platform compatibility challenges.
Debugging Platform-Specific Issues
The actual functionality was completed in about an hour, but debugging Apple's sharing restrictions took the remaining time. The key issues were:
Apple's Sharing Requirements:
- Source URL validation - Apple verifies the origin of shared content
- Title standardization - Consistent formatting across their ecosystem
- Limited developer control - Restricted customization options
The Solution Process:
- Read the documentation thoroughly - Apple's requirements aren't always obvious
- Experiment with different approaches - Trial and error with sharing options
- Understand platform policies - Accept that adaptation is necessary
The Role of AI in Modern Development
This project highlighted how AI-assisted development has changed the programming landscape:
Current Development Breakdown:
- 95% - AI can handle standard implementation
- 3% - Intelligent human reasoning and documentation review
- 2% - Senior engineers for complex architecture decisions
What AI Excels At:
- Basic feature implementation
- Standard API integrations
- Boilerplate code generation
- Common design patterns
What Requires Human Intelligence:
- Platform policy interpretation
- Edge case handling
- Architecture decisions
- User experience considerations
Lessons for New Developer Onboarding
1. Start with Platform Documentation
New developers must learn to read technical documentation as a core skill. In this case, understanding Apple's sharing policies was crucial.
2. Embrace Trial and Error
Iterative testing and experimentation often reveal platform-specific quirks that documentation doesn't cover.
3. Context Matters
Experienced developers bring crucial context about user behavior and platform restrictions that new developers lack.
Permission Management Considerations
An interesting learning moment occurred when our new developer implemented notification permissions alongside the share feature. While logical, this had to be removed because:
- User trust issues - New permission requests alarm users
- Bad review risk - Users interpret unexpected permissions as suspicious
- Context requirements - Understanding user psychology takes experience
This highlights why experienced oversight remains essential, even with AI assistance.
Best Practices for Cross-Platform Feature Development
- Before coding, understand how each platform handles the feature you're building.
- Design features that work within the most restrictive platform's constraints.
- Create internal documentation for future developers about platform quirks.
- Don't assume cross-platform compatibility without thorough testing.
Measuring Developer Productivity
This experience demonstrated that new non-technical developers can be highly productive when:
- Given clear, focused tasks
- Provided with proper tooling guidance
- Working on well-defined features
The key is balancing independence with oversight to avoid costly mistakes.
Conclusion
Building features with new developers requires patience and proper guidance, but the results can exceed expectations. Platform-specific constraints often present bigger challenges than the actual coding, making documentation skills and iterative testing crucial.
The evolution of AI-assisted development means new programmers can contribute meaningfully much faster than before, but human judgment remains essential for user experience and platform compliance decisions.
Looking to onboard new developers effectively? Focus on teaching documentation skills and platform-specific considerations alongside coding fundamentals.