Translated from the Korean original. Some screenshots show the original Korean interface.
Hi, I'm Gihwan Choi, a frontend developer on the FE1 Team. Over the past few years, the hottest topic in the development world has been AI. Many teams bring AI into their work expecting higher productivity, but in practice they run into one common problem.
"AI raised individual productivity, but the team's consistency and quality actually got worse."
AI raised productivity but cost us consistency
One by one, team members started using AI. Productivity clearly went up.
But problems surfaced in code review.
For the same component, one person wrote a 5-line Storybook story and another wrote 50 lines. Test code was the same. What AI produced was fast, but all over the place.
We ended up in a paradox: productivity went up, but quality control got harder.
Deliverables like docs, Storybook stories, and test code were written in each person's own style, and the team's output as a whole lost consistency. That's when we realized:
"Rather than knowing how to use AI well, we need an environment where AI can be used well."
1. Manage AI like code
The starting point was simple. Don't leave AI as an "individual tool"; manage it as a "team system".
So the team started managing prompts like code. Instead of everyone typing whatever they liked, we version-controlled prompts and treated them as a single team convention.
As a result, we built an environment where anyone, regardless of AI skill, can write a Storybook story of the same quality in 10 minutes.
Prompts are no longer just instructions. They are the consistency rules the team follows: code conventions for the AI era.
2. Syncing the whole team's AI capability (with MCP)
The quality of AI responses depends heavily on the input. But finding and entering the right context every time was a big burden for developers.
We focused on an environment where AI can fetch the information it needs by itself: MCP (Model Context Protocol).
The team used MCP to build an environment where AI can explore information on its own.
- Accurate UI implementation (Figma MCP): We let AI understand the design system precisely and implement UI that matches the Figma designs.
- Navigating a huge codebase (Serena MCP): We let AI find the modules and dependencies it needs among tens of thousands of lines of code efficiently, without getting lost.
- Verifying results (Playwright MCP): We let AI verify for itself how the final result of the code it wrote actually behaves in the browser.
By sharing and documenting MCP know-how quickly, everyone's AI became not just a tool that answers but one that understands the situation and acts on its own.
When needed, we also build our own MCP servers.
All of this was about widening the environment in which AI can be used well. We built, at the team level rather than the individual level, a system where AI can understand context by itself.
3. Two ways to resolve bottlenecks
With higher productivity, the team started tackling bottlenecks big and small. The approach followed two main tracks.
- First, rapid prototyping: quickly experimenting with and turning into tools the pain points developers run into.
- Second, building agentic workflows: using AI agents to handle complex work we couldn't attempt before.
3.1. Experiment and validate fast
AI shines in practice at the prototyping stage. When the team finds a bottleneck, we use AI to experiment quickly and turn the result into a tool.
✅ Cut onboarding that used to take hours down to minutes with a project starter kit
✅ Built debugging tools to make maintenance more efficient
✅ Eased bottlenecks in design collaboration with a Figma plugin
When team members found a problem, they immediately used AI to prototype a small solution and shared it.
3.2. Build AI systems for the team
With AI agents, even complex repetitive work that was impossible before can now be automated.
The team set up a GUI-based automation tool environment so anyone can build AI workflows through a visual interface without writing code. Key examples:
✅
/ai, /graph, /mr, and other AI workflows triggered by GitLab comments
✅ Automatic Wiki updates when code changes
✅ Morning and evening FE tech news briefings from the FE news bot
4. Bottlenecks go to AI, developers focus on what matters
With the AI environment and prototyping cutting bottlenecks, the team started spending time where it really matters: protecting software quality.
Test code was no longer a chore. AI wrote unit, integration, and E2E tests quickly, and we automated visual regression tests too.
As a result, the team experimented with 2,000 tests, cleaned out 1,400 unnecessary ones, and kept 600 stable tests along with improved prompt documents.
Documentation was the same. Since AI is good at "summarizing" and "structuring," it could produce easy-to-understand technical docs in 10 minutes.
We now actively write the tests and docs we used to put off for lack of time. We're not stopping at shipping features; we're building a development culture that systematically raises software quality.
5. Information sharing changed the team
Building this AI culture, we learned one important thing. No matter how good the tools and systems are, raising the whole team's level of use requires active information sharing.
So the team runs a channel for sharing, where we actively pass around the articles we've read and our insights.
Bill Gates once said:
"A high corporate IQ doesn't mean having many smart people. It depends on how easily information is shared and how well people build on each other's ideas."
Thanks to AI, the team now "shares" knowledge faster than it "finds" it. AI didn't stop at raising individual productivity; it lifted the whole team's collaboration to the next level.
6. Environment shapes culture
AI is a tool. But a good tool becomes a culture in itself. Instead of using AI as an individual tool, the FE1 Team focused on building an environment where everyone can use it well. Along the way, prompts became team conventions, and automation became part of the team's daily routine.
We didn't become "a team that uses AI well." We became "a team with an environment where AI can be used well."
The FE1 Team will keep expanding this environment. We plan to use AI to automate bottlenecks in the development process,
and to grow a culture that systematically raises quality through docs and tests.
Our goal isn't just efficiency. It's to use AI to free developers from repetitive work and create an environment where they can focus on the problems that really matter: the core value of software.
Not a world where AI writes code for us, but an environment where developers can think more deeply
That's the future the FE1 Team wants to build.
Related articles
