Chapter 11: The Coding Begins
Lin Feng waited until the house fell silent before closing his bedroom door and sitting cross-legged on his bed. The celebration dinner had been warm and joyful, but his mind had been elsewhere all evening. Now, finally alone, he could explore the discovery he'd made earlier.
Time to see if I can push this further.
He closed his eyes and focused inward, feeling for that familiar mental pathway to his soul space. The transition was smoother this time—like stepping through a doorway he'd walked through a hundred times before. The infinite white void materialized around him, and Logic Frame stood waiting in the center, its blue-silver form gleaming under sourceless light.
The Analysis Protocol interfaces he'd created earlier floated nearby, their holographic screens displaying idle status readouts. Lin Feng approached them, studying the wireframe structures and data tables he'd manifested through systematic thinking.
"This is just the beginning," he murmured, his voice echoing strangely in the mental space. "If I can create visual structures, what else is possible?"
He dismissed the Protocol screens with a thought and turned his attention to Logic Frame. The mecha remained motionless, awaiting his command. Lin Feng placed his hand against its leg, feeling the cool metal that existed only in his mind yet felt perfectly real.
"In my past life, I wrote code to solve problems. To automate tasks. To make systems work together." He pulled his hand back and began pacing. "Here, I can manifest logical structures directly. But can I create actual functional programs? Not just displays and interfaces, but executable code?"
The question hung in the air. Lin Feng stopped pacing and faced an empty section of the void. He raised his hand, palm out, and began thinking through the most basic programming concept he could imagine.
A simple loop. Count from one to ten.
He visualized the logic structure: initialization, condition check, execution, increment, repeat. The fundamental building blocks of any program. As he concentrated, something began to form in the space before him—faint lines of light, barely visible, sketching themselves in the air.
The text appeared not as words on a screen but as glowing strings that floated in three-dimensional space: Initialize counter at 1, while counter is less than or equal to 10, display counter, increment counter, end loop. Lin Feng's heart raced. The characters weren't English or Chinese—they were pure logic, comprehensible through intent rather than language.
"It's working," he breathed. "But is it actually executing, or just displaying?"
He reached toward the floating code and pushed his will into it, commanding it to run. The strings of light pulsed once, twice, and then numbers began appearing in sequence beside them: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10. Each number glowed for a moment before fading.
Lin Feng laughed, the sound echoing through the void. "Yes! It's not just visual—it's functional!"
Excitement surged through him. He dismissed the simple loop and began thinking bigger. If he could create executable code in his soul space, then he could build actual programs. And if the code ran here, where his mecha existed, then perhaps…
Perhaps I can create systems that integrate directly with Logic Frame.
He turned back to his mecha. "Let's start with something practical. Basic data collection about your functions."
Lin Feng settled into a meditative stance, floating in the void—his body position didn't matter here; it was more about mental focus. He began structuring his thoughts methodically, drawing on years of programming experience.
First, define what I need to monitor. Energy levels, structural integrity, system response time, synchronization rate. Then create data points that can track changes over time.
He extended his hands and began "writing" code in the air. Unlike his previous work creating the Analysis Protocol's visual interface, this felt different. He was building something that would run autonomously, collecting information without his constant attention.
The code manifested as interconnected strings of light, forming a web of logic that grew more complex with each addition. Lin Feng worked carefully, building function after function—energy monitoring subroutine, structural stress tracking, response latency measurement, synchronization stability checker, and data logging with timestamps.
Hours passed in the outside world, though time felt different in soul space. Lin Feng's consciousness remained sharp, focused entirely on his work. The mental fatigue he'd experienced during synchronization training didn't apply here—this was pure mental exercise, like solving an engaging puzzle rather than lifting a heavy weight.
As he worked, he noticed something fascinating. The code he created didn't just float randomly in the void. It naturally gravitated toward Logic Frame, forming connections with the mecha's structure. Thin threads of light extended from his program to various points on the mecha's body—energy core, joints, armor plating, weapon mounts.
"You're accepting it," Lin Feng said softly. "The mecha is integrating with the program because it recognizes the code as part of me. My thoughts, my logic, my systematic approach—it's all compatible because this is my soul space."
The realization was profound. Other pilots couldn't do this because they didn't think in terms of code and algorithms. They shaped their soul space through imagination and emotion. But Lin Feng's programmer mindset allowed him to build actual functional systems using logic structures.
He continued working, refining the data collection protocol. Error handling routines to prevent crashes. Optimization algorithms to minimize energy drain. Modular design so he could add new features later. Every principle of good software development applied here, translated into pure mental constructs.
Finally, after what felt like hours of intense focus, Lin Feng stepped back to examine his work. A complex network of glowing code surrounded Logic Frame, each string pulsing with soft light as data flowed through the system.
"Activate," he commanded.
The network flared brightly for a moment, and then information began flooding his consciousness—not as separate screens, but as direct knowledge integrated into his awareness. Logic Frame data collection active: energy capacity 500 out of 500 units, energy flow stable, structural integrity 100%, system response time 0.03 seconds, synchronization not active in soul space only mode, core temperature optimal. Data logging enabled, updating every half second, storage unlimited within soul space construct.
Lin Feng watched the data stream, his analytical mind already noting patterns. Even at rest, the mecha had subtle fluctuations—minor energy flows maintaining the soul bond, microscopic adjustments in structural stress as his consciousness interacted with it.
"This is exactly what I needed," he said, satisfaction warming his chest. "Now I have baseline data. Once I start synchronizing and fighting, I'll be able to track everything. Energy consumption patterns, stress points under combat load, optimal operating parameters…"
He walked around Logic Frame, observing how the data collection network interfaced with different mecha components. The code wasn't intrusive—it monitored without interfering, like sensors that observed without touching.
In my past life, I wrote programs to analyze user behavior, optimize game performance, and predict system failures. Here, I can do the same thing for combat. Every fight will generate data. Every enemy will become a case study. Every tactic will be measurable.
The possibilities were staggering. While other pilots relied on instinct and experience, Lin Feng could build a database of combat information. Pattern recognition algorithms could identify enemy weaknesses. Predictive models could calculate optimal responses. Machine learning principles could help his systems improve automatically over time.
"This is my advantage," Lin Feng murmured, clenching his fist. "Not raw talent. Not powerful equipment. Not family connections. Pure, systematic analysis combined with soul space programming. Nobody else can do this because nobody else thinks like a programmer."
He accessed the data collection program's core code, making a few final adjustments. Added more detailed timestamp logging. Improved the data compression algorithms. Created export functions so he could review the information outside of active soul space sessions.
As he worked, a thought struck him: This program will keep running even when I'm not consciously focused on it. It's become part of my soul space's background processes.
He tested the theory by shifting his attention away from the data stream to Logic Frame itself. The information flow dimmed but didn't disappear. The code continued executing, collecting data silently. When he focused on it again, updated readings appeared instantly—energy holding steady at 500 units, no structural changes, response time consistent.
"Autonomous operation," Lin Feng said with satisfaction. "Just like any good background service. It runs continuously, monitoring and logging, without requiring my active attention."
He glanced at Logic Frame, and an idea occurred to him. "If the data collection protocol can run autonomously, what about more complex programs? Could I create systems that actively assist during combat?"
The Analysis Protocol he'd built earlier was primarily observational—it displayed information and tracked patterns, but it required his interpretation and decision-making. What if he could build something more sophisticated? A tactical advisor that could process combat data and actually suggest optimal responses?
That's the next step. But I need real combat data first. The program can only be as smart as the information I feed it.
Lin Feng spent another hour refining the data collection protocol, adding categories he anticipated needing: enemy behavior classification, attack pattern frequency analysis, defensive vulnerability mapping, energy efficiency comparisons, environmental factor logging, and team coordination metrics. Each new feature added complexity to the code network, but Lin Feng kept the architecture clean and modular. He could add or remove features without breaking the core system—good programming practice translated directly into soul space development.
Finally, mentally exhausted but deeply satisfied, Lin Feng stepped back and surveyed his work one last time. The data collection protocol hummed quietly around Logic Frame, invisible to anyone but him, gathering information with each passing moment.
"Version 0.2," he said, naming the system. "The foundation for everything to come."
He reached out and touched one of the glowing code strings. It felt warm, responsive, alive in a strange way. This was his creation—born from his knowledge, shaped by his systematic thinking, and integrated with his soul mecha. No one else had anything like this. No one else could create anything like this.
In my previous life, I died helping someone who betrayed me. I was naive, trusting, and weak. But here, I have a second chance. With this system, with this approach, I won't just survive—I'll thrive.
Lin Feng opened his eyes, returning to his physical body in the bedroom. The sudden transition left him momentarily disoriented, his eyes adjusting to the darkness. He checked his phone: 3:47 AM. He'd been in soul space for over five hours, though it had felt like maybe two.
His body felt fine—no headaches, no mental fatigue like after synchronization training. Working in soul space with pure logic constructs was different from actively piloting his mecha. Less straining, more like extended meditation.
Lin Feng stood and stretched, walking to his window. The city lights twinkled in the distance, quiet and peaceful at this hour. Somewhere out there, thousands of other newly awakened pilots were probably sleeping, excited about their new mechas but following traditional training methods.
None of them were spending their nights writing code in their soul space. None of them had even conceived of such a possibility.
"Let them focus on equipment and raw power," Lin Feng whispered to his reflection in the window. "I'll build something they can't imagine. A systematic approach to combat. A programmable advantage that grows stronger with every fight."
He returned to bed, his mind already planning the next development phase. Once he had combat data, he could start building predictive algorithms. Once he understood enemy patterns, he could create countermeasure libraries. Once he mastered individual combat, he could expand to team coordination systems.
This is just the beginning. The coding has barely started.
Lin Feng closed his eyes, finally allowing himself to rest. The data collection protocol continued running in his soul space, silently gathering baseline information, preparing for the battles to come.
Tomorrow, he would begin testing his creation in practice. But tonight, he'd proven something crucial: his programming knowledge wasn't just useful—it was revolutionary. He could build functional systems directly in his soul space, creating advantages no other pilot possessed.
As sleep claimed him, Lin Feng smiled. The programmer pilot had just written his first true program in a dimension where code and consciousness merged. And this was only version 0.2.
The path to the peak had truly begun.